Misc Record

发表于2024-11-15|更新于2025-03-21|CTF

|总字数:25.7k|阅读时长:111分钟|浏览量:

Misc刷题

1.BUU刷题

终于刷到第七页了！

目标刷完第七页

目前进度（ 7 / 7 ）

1.签到

顾名思义，签到，复制提交就好

2.金三胖

简单的拆分gif，打开puzzlesolver一把梭

3.你竟然赶我走

010一把梭

4.二维码

用随波逐流分析一下发现有隐藏文件，binwalk提取出一个zip，加密的打开提示我们是4number，arp爆破出密码是7639，打开txt得到flag{vjpw_wnoei}

5.大白

随波逐流爆宽高即可

6.乌镇峰会种图

随波逐流一把梭

7.wireshark

查找password，追踪tcp流，得到password=ffb7567a1d4f4abdffdb54e022f8facd

8.N种方法解决

随波逐流梭出一张二维码，微信一扫就拿到flag

9.基础破解

Arp暴力破解密码得到密码是2563，txt是base64加密，解密就行

10.文件中的秘密

文件属性里有flag

11.zip伪加密

随波逐流伪加密修复即可

12.LSB

Lsb隐写，用stegsolve打开可以发现藏了一张png，保存下来是一张二维码，扫一下就好

13.被嗅探的流量

随波逐流一把梭

14.rar

Arp爆破得到密码8795，flag{1773c5da790bd3caff38e3decd180eb7}

15.qr

CQR扫一下就行

16.镜子里的世界

Zsteg一把梭

17.爱因斯坦

Binwalk提取zip，要密码，在图片的属性中可以看到密码，得到flag

18.ningen

图片先binwalk提取出zip，zip爆破密码得出8368，解密得到flag

19.小明的保险箱

图片先binwalk提取出zip，zip爆破密码得出7869，解密得到flag

20.Easycap

拖进winshark，追踪TCP流得到flag

21.隐藏的钥匙

010打开，查找base，得到加密过的数据。解密一下就是flag

22.另外一个世界

010打开后在文件末尾出现了一串神秘的二进制串，cherchef解密后恰好是flag

23.数据包中的线索

导出对象为http时，追踪tcp流得到一串神秘的base64加密，复制进随波逐流用base64转图片就能看到flag

24.神秘龙卷风

得到zip加密爆破得到密码5463，解密出的txt有多个+和.>，猜测为字频统计，以.>为分割，编写脚本得到flag

25.FLAG

得到的图片用stegsolve打开查看lsb，得到一个压缩包，解压后没有后缀

File一下发现是elf，用kali打开即可

26.假如给我三天光明

拿到png一看就知道是盲文加密，解密后是kmdonowg，即为压缩包密码，解压后得到一段摩斯密码的音频，对应解密后是flag

27.后门查杀

打开跟我说有病毒。。给我隔离了。。。

选择保留在电脑上，得到一个html文件夹

这里需要使用D盾来查杀

看到

得到密码，flag：flag{6ac45fb83b3bc355c024f5034b947dd3}

28.webshell后门

与上题类似。D盾扫描

在第一个文件中能看到pass，flag：flag{ba8e6c6f35a53933b871480bb9a9545c}

29.来首歌吧

简单的摩斯密码，打开audacity对照频谱图手敲莫斯密码即可

（ ↑ 为一部分频谱图）

1	...../-.../-.-./----./..---/...../-..../....-/----./-.-./-.../-----/.----/---../---../..-./...../..---/./-..../.----/--.../-../--.../-----/----./..---/----./.----/----./.----/-.-./

随波逐流解密即可

30.面具下的flag

得到一张知名男女图片，随波逐流一下可以发现有隐藏文件，binwalk提取一下可以发现得到一个压缩包，解压发现要密码

，可以发现zip是伪加密，修改后解压。

得到一个vmdk文件，搜了一下发现

“后缀为 .vmdk 的文件是 VMware 虚拟磁盘文件，通常用于虚拟机环境中存储虚拟机的磁盘数据。”

以为要用虚拟机的，但是打不开。~~于是看了一下wp~~

这里的flag.vmdk用010打开后搜 flag 等关键字样得到这个

这个

还有这个

直接复制好像解密不了。

打开kali，用kali自带的7z解密可以提取这些文件，输入

1	7z x flag.vmdk -o./

-o后面的./是把压缩的内容放在当前目录下，解压完成就能看见好几个文件夹

这是brainfuck加密和Ook! Obfuscation加密

brainfuck加密随波逐流里有

Ook! Obfuscation加密网站：Ook! Obfuscation解密网站

分别解密得到flag{N7F5_AD5_i5_funny!}

31.荷兰宽带数据泄露

拿到bin文件查了一下发现要用路由器解析的，用RouterPassView

打开后看了一下wp才知道username是flag

32.九连环

拿到jpg用010看一下，发现后面有压缩包隐藏的

先试一下随波逐流的binwalk提取，失败了，没提出来

于是我们用kali的binwalk

![2024-11-19 002930](./Misc-Record/2024-11-19 002930.png)

（不知道为什么我的binwalk要加一个–run-as=root提升权限。。）

提取出来的一个图片和一个压缩包，猜测密码在图片的隐写里

用steghide跑一下，真的在里面，提取

查看它，下面的就是密码

直接用密码解压压缩包就能看到flag：flag{1RTo8w@&4nK@z*XL}

33.认真你就输了

这题我学到了ms-office文件本质是zip

MS-Office文件word、excel、ppt本质都是zip文件，就可以隐写。把01.xls重命名为01.zip，解压缩后在 xl/charts 目录里有 flag.txt

34.被劫持的神秘礼物

拿到pcapng文件用wireshark打开，这里可以使用http.request.method==POST进行过滤或者一个个点开看，发现

![2024-11-19 113909](./Misc-Record/2024-11-19 113909.png)

得到账号密码adminaadminb，包上小写md5，flag{1d240aafe21a86afc11f38a45b541a49}

35.被偷走的文件

提到偷走文件一般要清楚是找HTTP或者FTP，看到导出对象里有FTP-DATA，保存这个flag.rar

保存下来发现要密码解压，爆破可以发现，密码是5790，得到flag

36.藏藏藏

得到一个jpg，用随波逐流的formost提取，得到一个zip，打开是个xlsx，一张二维码，用QR扫码得到flag

37.佛系青年

拿到的zip拖进随波逐流看一下，发现第一个jpg无加密，第二个txt伪加密，修复一下

jpg上说我FFF佛慈悲，txt内容为

发现是与佛论禅编码，随波逐流得到flag

38.你猜我是个啥

随波逐流一把梭

39.刷新过的图片

关键词“刷新”，很可能是F5-steganography加密，尝试解密

我这里不知道为什么还要加上

1	--add-opens java.base/sun.security.provider=ALL-UNNAMED

才能F5解密。。

得到一个txt文件，打开是乱码，却能看到首两个字母PK，改后缀为zip，解压

需要密码，发现是伪加密，随波逐流修复一下得到flag：flag{96efd0a2037d06f34199e921079778ee}

40.秘密文件

winshark打开，查看了一下http，ftp-data，啥也没有。。

过滤tcp流，看到提示，追踪tcp，发现隐藏了一个rar文件

用随波逐流的binwalk提取文件，得到rar，爆破密码发现是1903，得到flag：flag{d72e5a671aa50fa5f400e5d10eedeaa5}

41.鸡你太美

得到的zip一个是gif，另一个是损坏的gif，010打开发现缺少文件头，补上文件头即可拿到gif

这里注意flag不是zhi-yin-you-are-beautiful，不知道为啥是下划线zhi_yin_you_are_beautiful

得到flag：flag{zhi_yin_you_are_beautiful}

42.just_a_rar

得到的zip解压得到四位数.zip，直接爆破得到密码2016

拿到一张flag.jpg，拖进随波逐流得到flag

43.snake

拿到zip得到一个jpg，发现有隐藏文件

binwalk提取文件得到一个zip，zip里面是cyber和key

key里面是V2hhdCBpcyBOaWNraSBNaW5haidzIGZhdm9yaXRlIHNvbmcgdGhhdCByZWZlcnMgdG8gc25ha2VzPwo=

base64解密得到

What is Nicki Minaj’s favorite song that refers to snakes?

搜了一下是anaconda，所以这是真正的key

而cyber是serpent加密，解密网址http://serpent.online-domain-tools.com

解密得到flag

flag：flag{who_knew_serpent_cipher_existed}

44.菜刀666

放进随波逐流用formost提取出一个zip，但是要密码，而且爆破不出来

又看pcanp，过滤http.request.method==POST

发现1068的传了FF D8 FF E0 00 10 4A 46 49 46 00 01 ( JPG的文件头 )

复制下来进入010新建一个文件，保存图片得到

得到密码：Th1s_1s_p4sswd_!!!

解压得到flag：flag{3OpWdJ-JP6FzK-koCMAK-VkfWBq-75Un2z}

45.一叶障目

随波逐流一把梭

46.神奇的二维码

得到一张二维码，CQR扫一下发现不是flag

拖进随波逐流binwalk提取一下文件得到716A.rar 7104.rar 17012.rar 18394.rar

1.7104.rar

解压得到encode.txt

里面是YXNkZmdoamtsMTIzNDU2Nzg5MA==

base64解密一下是asdfghjkl1234567890

没用，看下一个。。

2.716A

解压得到一张 “已经可以了大佬你现在这个情况证明你已经无敌了” 的图片和一个看看flag在不在里面^_^.zip

用asdfghjkl1234567890解密zip，又得到一个 “已经可以了大佬你现在这个情况证明你已经无敌了” 的图片

没用，看下一个。。

3.17012.zip

解压得到一个flag.doc，里面是很长的字符

需要多次解码base64，网上找了个脚本

import base64

def decode(f):
	n = 0;
	while True:
		try:
			f = base64.b64decode(f)
			n += 1
		except:
			print('[+]Base64共decode了{0}次，最终解码结果如下:'.format(n))
			print(str(f,'utf-8'))
			break

if __name__ == '__main__':
	f = open('e:/Python 3.13/ccc.txt','r').read()
	decode(f)

跑一下脚本

得到如下：comEON_YOuAreSOSoS0great

下一个。。。

4.18394.rar

用comEON_YOuAreSOSoS0great去解密rar，得到一串音频，拖进aud

明显看出来是摩斯密码，手敲代码得

1	--/---/.-./..././../.../...-/./.-./-.--/...-/./.-./-.--/./.-/.../-.--

解密最后得到flag：flag{morseisveryveryeasy} (要注意是小写)

ps：这道题好烦。。

47.纳尼

拿到文件打不开一看就是缺少文件头，010里面补上47 49 46 38得到gif

用随波逐流分解帧间隔，得到Q1RGe3dhbmdfYmFvX3FpYW5nX2lzX3NhZH0=

base64解码得CTF{wang_bao_qiang_is_sad}，则flag：flag{wang_bao_qiang_is_sad}

48.excel破解

随波逐流一把梭

49.来题中等的吧

义眼顶针，鉴定为morse

1	.-/.-../.--./..../.-/.-../.-/-...

解密得ALPHALAB

则flag{alphalab}

50.梅花香自苦寒来

拿到png先用随波逐流跑一下，得到一串坐标，猜测是画图

网上找了一下，找到了gnuplot来画图，不过我们先要把括号和逗号去掉，脚本如下

with open('E:\meihuai.txt', 'r') as res:  # 坐标格式文件比如(7,7)
    re = res.read()
    res.close()
    
with open('E:\output.txt', 'w') as gnup:   # 将转换后的坐标写入output.txt
    re = re.split()
    tem = ''
    for i in range(0, len(re)):
        tem = re[i]
        tem = tem.lstrip('(')
        tem = tem.rstrip(')')
        for j in range(0, len(tem)):
            if tem[j] == ',':
                tem = tem[:j] + ' ' + tem[j+1:]
        gnup.write(tem + '\n')
    gnup.close()

去掉括号和逗号后用gnuplot画图

画完图后得到一个二维码，CQR扫一下得到flag：flag{40fc0a979f759c8892f4dc045e28b820}

51.谁赢了比赛？

拿到png用binwalk提取文件得到一个zip，有密码

arp爆破得到密码是1020

解压是一张gif，逐帧分解得到很多张棋谱和一张奇怪的图片

图片stegsolve一下在Red plane0得到一张二维码

CQR扫一下

得到flag：flag{shanxiajingwu_won_the_game}

52.[ACTF新生赛2020]outguess

拿到一堆东西，txt里让我们guess一下flag在哪，一看就很明显是旁边的mmm.jpg里

而且是outguess隐写

这里我们要注意的是直接去无密文outguess会显示

[!WARNING]

Extracted datalen is too long

说明是有密文的

发现吗，mmm.jpg的属性里面有：公正民主公正文明公正和谐

社会主义核心价值观解码: abc

abc作为密文outguess.

得到flag：flag{gue33_Gu3Ss!2020}

53.[WUSTCTF2020]find_me

一定一定要多看属性！

属性备注里面有盲文 ⡇⡓⡄⡖⠂⠀⠂⠀⡋⡉⠔⠀⠔⡅⡯⡖⠔⠁⠔⡞⠔⡔⠔⡯⡽⠔⡕⠔⡕⠔⡕⠔⡕⠔⡕⡍=

随波逐流解密得到flag：flag{y$0$u_f$1$n$d$_M$e$e$e$e$e}

54.穿越时空的思念

得到音频听一下能在右声道发现明显的莫斯密码，手敲得

..-./-----/..---/----./-.../-../-..../..-./...../...../.----/.----/...--/----./././-.././-.../---.././....-/...../.-/.----/--.../...../-.../-----/--.../---../-..../..-./-----/..---/----./-.../-../-..../..-./.....

解密，得F029BD6F551139EEDEB8E45A175B0786F029BD6F5

取前32位小写得flag：flag{f029bd6f551139eedeb8e45a175b0786}

55.[SWPU2019]我有一只马里奥

得到一个exe，执行后得到1.txt，里面写着ntfs flag.txt

~~有点不会了，看了下wp~~

查到了

[!NOTE]

NTFS交换数据流（简称ADS）是NTFS磁盘格式的一个特性，在NTFS文件系统下，每个文件都可以存在多个数据流，除了主文件流之外还可以有许多非主文件流寄宿在主文件流中，而我们无法查看到非主文件数据流，因文件夹大小始终显示0

以下是进行文件流计生和查看的方法，以后在windows命令行下查看文件，都用 dir /r

[!NOTE]

寄生一:

echo 写入内容>>宿主文件:交换数据流文件(寄生文件)

echo ever>>1.txt:2.txt

2.txt为echo创建出交换数据流文件，ever在2.txt中

寄生二:

type 交换数据流文件(寄生文件)>>宿主文件夹:交换数据流文件(寄生文件)

type 2.txt>>temp:2.txt

temp为空文件夹,执行后2.txt寄生在temp文件夹上

type a.jpg>>temp:a.jpg

temp为空文件夹,执行后a.jpg寄生在temp文件夹上

查看:

notepad 宿主文件:交换数据流文件(寄生文件）

notepad 1.txt:2.txt

查看图片文件:

mspaint 宿主文件:交换数据流文件(寄生文件)

notepad a.jpg:b.jpg

过滤

dir /r | findstr $DATA （过滤DATA字符串）

这道题应该是利用ntfs把flag.txt隐藏了

需要我们先建立一个文件夹来存放1.txt，再cmd，然后直接查看flag.txt

运行这个notepad 1.txt:flag.txt后就能看到flag：flag{ddg_is_cute}

56.[GUET-CTF2019]KO

打开文本是明显的Ook!加密

拖进在线网站直接解密就好（网站见Misc Ultra）

flag：flag{welcome to CTF}

57.[ACTF新生赛2020]base64隐写

解压zip得到一个txt和hint

txt里面是多行base64加密过的，复制进随波逐流

选择“base64隐写解密”直接得到flag：flag{6aseb4_f33!}

（？？？

看了一下wp发现这题base64解密过后是一个python2脚本，需要复制进kali跑脚本出flag

没啥好说的，随波逐流太好用了。。还能顺手给你把脚本跑了。。

58.[MRCTF2020]ezmisc

随波逐流爆破宽高得

flag：flag{1ts_vEryyyyyy_ez!}

59.[GXYCTF2019]gakki

拿到wolaopo.jpg，发现有文件隐写

binwalk提取得到zip，有密码

arp爆破得密码是8864，拿到一个毫无规律的txt，里面如同乱码

~~查了一下wp~~

最后发现是要我们统计字符，利用puzzlesolver

flag就是频率前几个的

flag：flag{gaki_IsMyw1fe}

（脑洞好大这题）

60.[HBNIS2018]caesar

全文：

题目：caesar

描述：gmbhjtdbftbs

flag格式：XXX 明文

提交：直接提交明文 （小写）

直接凯撒解密得flagiscaesar

flag：flag{flagiscaesar}

61.[SUCTF2018]single dog

拿到jpg发现后接了文本，binwalk提取一下是个zip

解压得1.txt里面是一堆颜文字，查了一下是AAencode，除此之外还有jjencode、ppencode、rrencode、uuencode、xxencode

利用随波逐流解密即可，也可以用在线网站http://www.hiencode.com/

解码得flag：flag{happy double eleven}

62.黑客帝国

zip解压一下看到很长的txt，开头是52617221，是rar文件头

010存一下，得到rar，解压要密码，爆破得到3690

解压得到一个png，但是打不开，010看一下

看出来后面JFIF是jpg的，且看到010最后面是FF D9

应该是修改了文件头，改回jpg即可

(PNG（png)文件头：89 50 4E 47　文件尾：AE 42 60 82）
(JPEG (jpg)文件头：FF D8 FF　　文件尾：FF D9　)

拿到图片

flag：flag{57cd4cfd4e07505b98048ca106132125}

63.[HBNIS2018]低个头

全文：

题目：低个头

描述：EWAZX RTY TGB IJN IO KL 请破解该密文 f

lag格式：XXX 明文

提交：直接提交明文（大写）

脑洞题。。。~~查了一下wp~~

题目“低个头”的意思竟然是让你低头看键盘

而那些字母在键盘上组合起来组成CTF。。

所以flag：flag{CTF}

64.[SWPU2019]伟大的侦探

zip是有密码的，而且爆破不出来

密码txt里面有一串乱码是密码

这里需要我们用010打开txt，而且在视图上选择EBCDIC（还不清楚为什么。。

就能得到密码：wllm_is_the_best_team!

然后就得到了很多小人的图片

这个对照表在随波逐流/其他工具/更多图形密码（在线）里面能找到

对照出来是iloveholmesandwllm

flag：flag{iloveholmesandwllm}

65.[MRCTF2020]你能看懂音符吗

压缩包解压不了，010打开发现修改了文件头

改回来，解压，得到一个docx文档，里面没啥内容

将文档后缀改成zip，打开document.xml，看到

是一串音乐加密的数据

♭♯♪‖¶♬♭♭♪♭‖‖♭♭♬‖♫♪‖♩♬‖♬♬♭♭♫‖♩♫‖♬♪♭♭♭‖¶∮‖‖‖‖♩♬‖♬♪‖♩♫♭♭♭♭♭§‖♩♩♭♭♫♭♭♭‖♬♭‖¶§♭♭♯‖♫∮‖♬¶‖¶∮‖♬♫‖♫♬‖♫♫§=

随波逐流解密得MRCTF{thEse_n0tes_ArE_am@zing~}

flag：flag{thEse_n0tes_ArE_am@zing~}

66.我吃三明治

得到一张三明治图片，formost一下还是一张三明治，010打开看到

藏了

1	MZWGCZ33GZTDCNZZG5SDIMBYGBRDEOLCGY2GIYJVHA4TONZYGA2DMM3FGMYH2

在两张图片之间（就像三明治一样。。

base32解码得flag：flag{6f1797d4080b29b64da5897780463e30}

67.[SWPU2019]你有没有好好看网课

得到两个zip，第二个zip爆破密码是183792

打开得到docx和影流之主

~~脑洞题，查了一下wp~~

docx的内容是：

提示我们在视频的5.20秒和7.11秒有问题

使用potplayer逐帧查看，分别看到

和

1 2	..... ../... ./... ./... ../ dXBfdXBfdXA=

第一个是敲击码，第二个是base64

解码分别得wllm和up_up_up，拼接得到wllmup_up_up

这是第一个zip的解压密码

解压出来得到一张jpg，随波逐流得到flag：flag{A2e_Y0u_Ok?}

68.[ACTF新生赛2020]NTFS数据流

这里需要注意的是解压软件的选择，不能用bandizip，否则会没有ntfs

建议选择winrar

winrar解压完zip后，直接 dir /r ，过滤 $DATA字符串

看到有隐藏后直接notepad

得到flag：flag{AAAds_nntfs_ffunn?}

69.sqltest

拿到文件进winshark分析一下发现是sql注入攻击

而且是sql盲注，它是用ascii码的大小比较来判断库名、表名、字段名和字段值的内容的

打开文件如下

这里看出来是sql了，可以先过滤一下http流量

再选择 /文件/导出分组解析结果/AS CSV

这样就可以把流量导出成表格。看得更清楚

一般来说，前面的内容是hacker来判断数据库名、表名、字段名的，我们直接拉到最下面

![2024-11-22 003853](./Misc-Record/2024-11-22 003853.png)

可以发现红框框起来的数字不同的是不同的对flag的尝试

hacker使用二分法爆破出flag内容，在对一个字符进行bool判断时，被重复判断的ASCII值就是正确的字符。

如上图是55和125

这里我们需要找到ascii开始判断flag的部分来提取，或者可以从下往上提取

最后提取如下

1	102, 108, 97, 103, 123, 52, 55, 101, 100, 98, 56, 51, 48, 48, 101, 100, 53, 102, 57, 98, 50, 56, 102, 99, 53, 52, 98, 48, 100, 48, 57, 101, 99, 100, 101, 102, 55, 125

ascii码解密得到flag：flag{47edb8300ed5f9b28fc54b0d09ecdef7}

70.john-in-the-middle

拿到pcanp文件可以先拖到随波逐流，binwalk一下没有提取出什么东西

formost一下发现提取出了几张图片，逐个对图片进行分析。

发现有个三角形状的图片在stegsolve可以看到flag

flag：flag{J0hn_th3_Sn1ff3r}

71.[UTCTF2020]docx

word本质是zip，改后缀名，在word/media目录里找到image23.png

里面有flag

flag：flag{unz1p_3v3ryth1ng}

72.[ACTF新生赛2020]swp

拿到zip先解压，拿到pcapng可以先尝试formost提取一下

提取出一堆图片，gif和一个zip

zip解压过后得到一个flag.swp

可以用010打开，发现

得到ctf{c5558bcf-26da-4f8b-b181-b61f3850b9e5}

flag：flag{c5558bcf-26da-4f8b-b181-b61f3850b9e5}

73.[GXYCTF2019]SXMgdGhpcyBiYXNlPw==

题目解码为Is this base?

解压zip得到一个txt，里面是多行base64，解密

解密后得到一首法语诗词，，

可以在随波逐流里选择 base64隐写解密，得到GXY{fazhazhenhaoting}

flag：flag{fazhazhenhaoting}

74.间谍启示录

得到iso映像文件，foremost提取一下

发现得到了个exe和一个压缩包

exe运行得到文件已被销毁.exe

压缩包解压得到文件已被销毁.exe和文件已被销毁.ico和flag.exe

运行flag.exe，就能看到机密文件.txt（记得要在显示里面把隐藏内容勾选上）

flag：flag{379:7b758:g7dfe7f19:9464f:4g9231}

75.喵喵喵

得到一张小猫图片，在stegsolve里面发现在RGB三色的0通道有异常，猜测是lsb隐写

顺序是BGR时得到

是一张png，保存下来，却发现打不开

010查看发现文件头有问题，我们修改一下

查看后发现是半张二维码

二维码拖进随波逐流爆破宽高得到整张二维码

扫了之后发现给了一个网盘地址

网盘https://pan.baidu.com/s/1pLT2J4f

得到一个txt文件，写着：flag不在这里哦你猜猜flag在哪里呢？找找看吧

猜测为ntfs，扫描，提取

得到一个pyc

[!NOTE]

.pyc 是 Python 编译后的字节码文件，通常是在运行 Python 脚本时由解释器自动生成，用于加速程序运行

想查看 .pyc 文件的源码，可以使用反编译工具 uncompyle6 将其还原为 .py 文件。

使用uncompyle6进行反编译。或者使用在线网站 https://tool.lu/pyc/

这个我使用在线网站，因为不知道为什么我的uncompyle6反编译出来的有点问题，也许是反编译的版本是3.12.7和2.7不同的问题。。

得到如下代码：

#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
# Version: Python 2.7

import base64


def encode():
    flag = "*************"
    ciphertext = []
    for i in range(len(flag)):
        s = chr(i ^ ord(flag[i]))
        if i % 2 == 0:
            s = ord(s) + 10
        else:
            s = ord(s) - 10
        ciphertext.append(str(s))
    return ciphertext[::-1]


ciphertext = [
    "96",
    "65",
    "93",
    "123",
    "91",
    "97",
    "22",
    "93",
    "70",
    "102",
    "94",
    "132",
    "46",
    "112",
    "64",
    "97",
    "88",
    "80",
    "82",
    "137",
    "90",
    "109",
    "99",
    "112",
]

这里看到对flag进行了加密，我们解密一下，解密脚本：

def decode(ciphertext):
    # 将密文恢复到加密前的顺序
    ciphertext = list(map(int, ciphertext[::-1]))
    flag = []
    
    for i, s in enumerate(ciphertext):
        if i % 2 == 0:
            s -= 10
        else:
            s += 10
        # 进行异或操作还原原始字符
        flag.append(chr(s ^ i))
    
    return "".join(flag)


ciphertext = [
    "96",
    "65",
    "93",
    "123",
    "91",
    "97",
    "22",
    "93",
    "70",
    "102",
    "94",
    "132",
    "46",
    "112",
    "64",
    "97",
    "88",
    "80",
    "82",
    "137",
    "90",
    "109",
    "99",
    "112",
]

# 解码密文
flag = decode(ciphertext)
print("Decoded flag:", flag)

解密出flag：flag{Y@e_Cl3veR_C1Ever!}

76.小易的u盘

拿到iso我们可以foremost提取一下或者解压一下

拿到一大推文件，先看inf

inf里面是

1 2	[AutoRun] Open=autoflag - 副本 (32)

[!NOTE]

inf文件中包含硬件设备的信息或脚本以控制硬件操作，inf是微软为硬件设备制造商发布其驱动程序推出的一种文件格式。inf文件中包含了硬件驱动安装的信息，比如、安装到哪一个文件夹中、怎样在注册表中加入自身相关信息、源文件在哪里等

autorun.inf 里面 Open的含义
含义：指定设备启用时运行之命令行。
格式：Open=命令行（命令行：程序路径名 [参数])
参数：
命令行：自动运行的命令行，必须是 .exe、.com、.bat 文件，其他格式文件可以使用start.exe打开或使用ShellExecute命令。

说明它自动运行autoflag-副本（32）

我们尝试运行的时候会报错，使用ida反编译试试

发现flag

flag：flag{29a0vkrlek3eu10ue89yug9y4r0wdu10}

77.[WUSTCTF2020]爬

附件没有后缀，010打开发现是pdf文件，改后缀后打开

提示我们flag被图片盖住了，使用在线编辑pdf网站： https://smallpdf.com/

移开图片看到：

Hex解密得：wctf2020{th1s_1s_@_pdf_and_y0u_can_use_phot0sh0p}

flag：flag{th1s_1s_@_pdf_and_y0u_can_use_phot0sh0p}

78.[RoarCTF2019]黄金6年

下载是一个MP4文件，010打开发现结尾有

是base64，解码发现有rar字样，猜测为压缩包，使用cyberchef

先base64解码再hex加密就能得到rar的十六进制，使用010保存下来，得到rar，解压需要密码

使用potplayer逐帧查看视频，发现几个二维码

（服了，考察眼力。。

解码之后分别是 key1:i key2:want key3:play key4:ctf

连起来就是压缩包密码，iwantplayctf，得到roarctf{CTF-from-RuMen-to-RuYuan}

flag：flag{CTF-from-RuMen-to-RuYuan}

79.[WUSTCTF2020]alison_likes_jojo

得到两张图片。boki.jpg和jljy.jpg

先处理boki，发现有隐写，binwalk提取一下

得到一个zip，有密码，爆破得到密码是888866，解压得到

WVRKc2MySkhWbmxqV0Zac1dsYzBQUT09

经过三次base64解码得到killerqueen

再处理jljy.jpg，最后发现是outguess隐写

成功提取，得到 wctf2020{pretty_girl_alison_likes_jojo}

flag：flag{pretty_girl_alison_likes_jojo}

80.[安洵杯 2019]吹着贝斯扫二维码

得到一个flag.zip和一堆东西，zip用winrar打开发现有注释

1	GNATOMJVIQZUKNJXGRCTGNRTGI3EMNZTGNBTKRJWGI2UIMRRGNBDEQZWGI3DKMSFGNCDMRJTII3TMNBQGM4TERRTGEZTOMRXGQYDGOBWGI2DCNBY

这个先解不出来，尝试别的

010随便打开一个文件可以发现是jpg文件，后缀改为jpg后就可以打开

这里可以cmd打开后 ren * *.jpg 批量改后缀（网上学的

发现这里应该是二维码拼接，而且010随便拖进去一个jpg发现在最后有神秘数字

猜测为拼接顺序，根据数字重命名文件

初见端倪：

试着扫了一下，果然扫不出来，要用ps拼接，，或者使用PPT拼接，我这里使用ppt

拼接完如下：

（累死lz了。。）

扫码，扫出来得到

1 2	BASE Family Bucket ??? 85->64->85->13->16->32

回想注释里得到的神秘数字，我们利用base家族反向解密，其中13指的是rot13

得到：ThisIsSecret!233 为解压缩密码

解压zip，得到flag{Qr_Is_MeAn1nGfuL}

flag：flag{Qr_Is_MeAn1nGfuL}

81.从娃娃抓起

全文：

题目描述：伟人的一句话，标志着一个时代的开始。那句熟悉的话，改变了许多人的一生，为中国三十年来计算机产业发展铺垫了道路。两种不同的汉字编码分别代表了汉字信息化道路上的两座伟大里程碑。请将你得到的话转为md5提交，md5统一为32位小写。

0086 1562 2535 5174
bnhn s wwy vffg vffg rrhy fhnv
请将你得到的这句话转为md5提交，md5统一为32位小写。
提交格式：flag{md5}

两行加密的，提醒我们都是汉字编码，随波逐流解密试试

第一行经过中文电报解码得到：

人工智能

第二行经过五笔字型解码，得到：

也要从娃娃抓起

解密网址： http://life.chacuo.net/convertwubi（这个是五笔输入的网址，需要你一个个打出来）

总的：人工智能也要从娃娃抓起

包上md5得到：3b4b5dccd2c008fe7e2664bd1bc19292

flag：flag{3b4b5dccd2c008fe7e2664bd1bc19292}

82.弱口令

ZIP是加密的，看备注里面是一堆空白

出不来，查了一下发现要用sunblime，打开发现

貌似是莫斯密码，手敲得到

1	.... . .-.. .-.. ----- ..-. --- .-. ..- --

解码得到：HELL0FORUM

解压zip，得到女神.png

看了wp才知道有个cloacked-pixel隐写

装好cloacked-pixel后kali解密得到flag

得到flag：flag{jsy09-wytg5-wius8}

83.Mysterious

得到一个exe，一看就是反编译题目，使用ida打开

先f5看函数，步入winmain，再步入dialogfunc，之后步入sub_401090

看到flag

flag：flag{123_Buff3r_0v3rf|0w}

84.[GUET-CTF2019]zips

得到zip解压得到222.zip

爆破得到密码723456

然后得到一个111.zip

111.zip可以发现是伪加密，破解后得到flag.zip和一个sh

setup.sh里面的内容是

1
2
3

#!/bin/bash
#
zip -e --password=`python -c "print(__import__('time').time())"` flag.zip flag

发现zip是将时间戳当作密码

于是我们使用掩码爆破

发现flag.zip创建时间2019-05-17 08:25:28

先用py跑出临近一个小时的时间戳

得到时间戳区间

1 2	1558051200.0 1558054800.0

而且因为小数点后不确定，可以从第一位进行尝试

接下来使用arp进行掩码爆破

爆破出密码1558080832.15

解压得到flag：flag{fkjabPqnLawhvuikfhgzyffj}

85.[UTCTF2020]file header

顾名思义是考文件头的，我们打开后是一张图片，发现打不开，于是拖进010发现少了png的文件头，补上。

然后就能拿到flag：flag{3lit3_h4ck3r}

86.zip

拿到了很多的zip，但是每个zip文件内容都很短，意思是要我们爆破crc

网上找了个脚本

import zipfile
import string
import binascii

string=string.printable
crc_s=''
for i in range(0,68):
    zip_name= "out" + str(i) + ".zip"    #读每个文件
    zip_crc=zipfile.ZipFile(zip_name,'r').getinfo('data.txt').CRC
    #读crc
    print(zip_crc)
    for a in string:
        for b in string:
            for c in string:
                for d in string:
                    s=a+b+c+d
                    #进行爆破
                    if zip_crc == (binascii.crc32(s.encode())):
                        print(s)
                        crc_s+=s
print(crc_s)

最后爆破出来得到

z5BzAAANAAAAAAAAAKo+egCAIwBJAAAAVAAAAAKGNKv+a2MdSR0zAwABAAAAQ01UCRUUy91BT5UkSNPoj5hFEVFBRvefHSBCfG0ruGnKnygsMyj8SBaZHxsYHY84LEZ24cXtZ01y3k1K1YJ0vpK9HwqUzb6u9z8igEr3dCCQLQAdAAAAHQAAAAJi0efVT2MdSR0wCAAgAAAAZmxhZy50eHQAsDRpZmZpeCB0aGUgZmlsZSBhbmQgZ2V0IHRoZSBmbGFnxD17AEAHAA==

cyberchef一下得到

发现是一个文件，down下来010看到

猜测是缺少rar文件头，补上。

然后就能在注释里发现flag

flag：flag{nev3r_enc0de_t00_sm4ll_fil3_w1th_zip}

87.[XMAN2018排位赛]通行证

拿到一串a2FuYmJyZ2doamx7emJfX19ffXZ0bGFsbg==

base64解密之后是kanbbrgghjl{zb____}vtlaln

然后最神奇的地方来了，我猜到这里要继续解密，但迟迟不出

最后看了wp发现应该用W型栅栏加密（注意是加密而不是解密）

然后得到kzna{blnl_abj_lbh_trg_vg}

一眼凯撒，解密得到 xman{oyay_now_you_get_it}

flag：flag{oyay_now_you_get_it}

88.[WUSTCTF2020]girlfriend

主要得到一个zip，解压出来是一段wav

一下就能听出来时拨号音识别

随波逐流一下

得到

1	99966688277733699944444777555333777444336637777

手机上九宫格按一下，次数对应长按的第几个，然后就能得到flag（记得要换小写）

flag：flag{youaremygirlfriends}

89.[DDCTF2018](╯°□°）╯︵ ┻━┻

全文如下：

(╯°□°）╯︵ ┻━┻
50pt

(╯°□°）╯︵ ┻━┻

d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9b2b2e1e2b9b9b7b4e1b4b7e3e4b3b2b2e3e6b4b3e2b5b0b6b1b0e6e1e5e1b5fd

这串东西16进制转换得到（注意要切片，2个2个一组）

212 232 225 244 160 247 225 243 160 230 225 243 244 161 160 212 232 229 160 230 236 225 231 160 233 243 186 160 196 196 195 212 198 251 185 178 178 225 226 185 185 183 180 225 180 183 227 228 179 178 178 227 230 180 179 226 181 176 182 177 176 230 225 229 225 181 253

发现数字好大，但是这一组组的数字联想到ascii，试着全减去128，得到（这里的偏移也可以脚本试出来应该）

84  104  97  116  32  119  97  115  32  102  97  115  116  33  32  84  104  101  32  102  108  97  103  32  105  115  58  32  68  68  67  84  70  123  57  50  50  97  98  57  57  55  52  97  52  55  99  100  51  50  50  99  102  52  51  98  53  48  54  49  48  102  97  101  97  53  125

然后转化ascii就能得到

1	That was fast! The flag is: DDCTF{922ab9974a47cd322cf43b50610faea5}

flag：flag{922ab9974a47cd322cf43b50610faea5}

90.[MRCTF2020]千层套路

得到一个压缩包，解压一下发现有个0573.zip，解压密码刚好是0573

得到一个0114.zip，猜测有多个类似的压缩包

网上找了个脚本，如下

import os
import zipfile
 
 
def extract_and_store_final_file(initial_zip_path, target_dir):
    if not os.path.exists(target_dir):
        os.makedirs(target_dir)
 
    current_zip_path = initial_zip_path
 
    password = os.path.basename(initial_zip_path)[:4]
 
    while True:
        with zipfile.ZipFile(current_zip_path, 'r') as zip_ref:
            files = zip_ref.namelist()
            file_name = files[0]
            next_zip_name = os.path.join(target_dir, file_name)
            try:
                zip_ref.extractall(target_dir, pwd=bytes(password, 'utf-8'))
                print(f"Extracted {file_name} to {target_dir} using password {password}")
            except RuntimeError as e:
                print(f"Error extracting {file_name}: {e}")
                break
 
            if file_name.endswith('.zip'):
                current_zip_path = next_zip_name
                password = file_name[:4]
            else:
 
                print(f"The final file is {file_name}, stored in {target_dir}")
                break
 
 
 
initial_zip_path = '0573.zip' #第一个解密的压缩包名称
target_dir = 'flag' #放进的文件夹
extract_and_store_final_file(initial_zip_path, target_dir)

千层套路还真是有一千个压缩包。。

最后得到一个qr.txt，看了一眼发现是

感觉是二维码之类的，要RGB数据串转图片一下

随波逐流一下，得到一个二维码

扫一下得到flag：flag{ta01uyout1nreet1n0usandtimes}

91.百里挑一

pcap里面有一堆jpg，然而似乎并没什么卵用

直接分组字节流，搜索flag就能发现前半段flag

1	flag{ae58d0408e26e8f

然后在flag旁边发现http://ns.adobe.com/xap，疑似关键词

搜索adobe，发现后半段flag

1	26a3c0589d23edeec}

连起来得到flag：flag{ae58d0408e26e8f26a3c0589d23edeec}

92.[SUCTF2018]followme

拿到pcapng，随波逐流一把梭

看到CTF{password_is_not_weak}

flag：flag{password_is_not_weak}

93.[MRCTF2020]CyberPunk

拿到cyberpunk! .exe，直接运行程序看到

提示我们时间2020.9.17，我们修改电脑时间为2020.9.17

修改完成后重新启动程序就能看到flag了

flag：flag{We1cOm3_70_cyber_security}

94.[BSidesSF2019]zippy

拿到pcapng直接foremost一下，得到一个zip，爆破一下发现爆不出来

搜索一下password，发现

1	unzip -P supercomplexpassword flag.zip

所以supercomplexpassword就是解压密码

得到flag：flag{this_flag_is_your_flag}

95.[安洵杯 2019]Attack

拿到的pcap直接foremost，得到一个zip

zip里有一个注释这可是administrator的秘密，怎么能随便给人看呢？

感觉是电脑密码有关的，看到流量包里面有一个lsass.dmp

dmp文件是windows系统中的错误转储文件，当Windows发生错误蓝屏的时候，系统将当前内存【含虚拟内存】中的数据直接写到文件中去，方便定位故障原因。

里面包含主机用户密码信息

.dmp文件binwalk和foremost提不出来，需要我们手动提一下

提出来之后用mimikatz分析文件，下载地址发行版 2.2.0 20220919 Djoin parser & Citrix SSO Extractor · gentilkiwi/mimikatz · GitHub

这个是已经打包好的exe，直接运行就行

96.[UTCTF2020]basic-forensics

得到一个jpeg，实则不然，010打开发现只有文字。

直接txt打开，搜索flag发现utflag{fil3_ext3nsi0ns_4r3nt_r34l}

flag：flag{fil3_ext3nsi0ns_4r3nt_r34l}

97.[SUCTF 2019]Game

一个zip和一张图片，zip里html打开发现

得到suctf{hAHaha_Fak3_F1ag}，好吧是假的

图片在lsb里发现

1	U2FsdGVkX1+zHjSBeYPtWQVSwXzcVFZLu6Qm0To/KeuHg8vKAxFrVQ==

base64显示Salted__，是加了盐的

使用网站进行解密在线Triple DES加密 | Triple DES解密- 在线工具，密钥就是之前的假密码

得到suctf{U_F0und_1t}

flag：flag{U_F0und_1t}

98.USB

得到一个233.rar和一个key.ftm

key.ftm用foremost分离出两个zip，解压出来是一个key.pcap

打开发现是usb流量，使用UsbKeyboardDataHacker

地址这里 GitHub - WangYihang/UsbKeyboardDataHacker: USB键盘流量包取证工具 , 用于恢复用户的击键信息

使用它，发现

1	key{xinan}

然后我们回过头来看压缩包，压缩包拖进010发现报错了

修改文件头把7A改成74

然后就能发现压缩包凭空多出来一张png

lsb一下发现一个二维码

扫一下得到

1	ci{v3erf_0tygidv2_fc0}

结合之前得到的key维吉尼亚解密一下得到

1	fa{i3eei_0llgvgn2_sc0}

隐约见到flag字符，栅栏解密得到flag：flag{vig3ne2e_is_c00l}

99.[DDCTF2018]流量分析

提示我们补齐私钥格式，而打开发现没有http流，猜测为http被加密了

我们接着寻找tcp及其中的私钥

搜索

1	tcp contains"KEY"

发现了三个流，依次追踪tcp流

在第二个tcp流中发现了一个被base64加密的图片

使用随波逐流的base64转图片得到

提取其中文字，并保存在新建的文本中（不放心的话可以在这里转换一下md5和提示里的相比较）

接下来就是添加解密私钥，查看http明文了

编辑-首选项-Protocols-TLS-Edit-+-Key File-Browse

查看http，发现就两个流

在第二个流里发现DDCTF{0ca2d8642f90e10efd9092cd6a2831c0}

flag：flag{0ca2d8642f90e10efd9092cd6a2831c0}

100.[GUET-CTF2019]虚假的压缩包

解压压缩包发现一个虚假的压缩包和一个真实的压缩包

虚假的压缩包可以用7z解压出来，看到一个key.txt，内容如下

数学题
n = 33
e = 3
解26

-------------------------
答案是

这里应该就是考我们rsa加密了

脚本（网上找的，当然不用脚本也可以用ai直接算出答案）：

 import gmpy2
 
def find_pq(n):
    for p in range(2, int(n**0.5) + 1):
        if n % p == 0:
            q = n // p
            return p, q
    return None
 
def rsa_decrypt(n, e, c):
    p, q = find_pq(n)
    phi_n = (p - 1) * (q - 1)
    d = gmpy2.invert(e, phi_n)
    m = pow(c, d, n)
    return m
 
n = 33  # 替换为实际的n值
e = 3 # 替换为实际的e值
c = 26  # 替换为实际的密文c值
 
plaintext = rsa_decrypt(n, e, c)
 
print("明文m为:", plaintext)
 
 
#请注意，上述代码中的 n、e、c 需要根据实际情况进行替换。

最后得出答案是5

用答案是5解压一个真实的压缩包

得到一张没卵用且会浪费你时间的图片.jpg 和亦真亦假

把一张没卵用且会浪费你时间的图片.jpg直接拖进随波逐流发现压缩了宽高，下方是：

我们对另一个文件进行异或5

使用随波逐流，选择进制转换/16进制字符串异或（不用随波逐流的话也可以网上找脚本）

保存的hex.txt使用010另存为文件

看到504B0304的文件头本来以为是zip，结果一打开才发现是docx

打开之后全标红发现：

1	flag{_th2_7ru8_2iP_}

101.[RCTF2019]draw

全文：

cs pu lt 90 fd 500 rt 90 pd fd 100 rt 90 repeat 18[fd 5 rt 10] lt 135 fd 50 lt 135 pu bk 100 pd setcolor pick [ red orange yellow green blue violet ] repeat 18[fd 5 rt 10] rt 90 fd 60 rt 90 bk 30 rt 90 fd 60 pu lt 90 fd 100 pd rt 90 fd 50 bk 50 setcolor pick [ red orange yellow green blue violet ] lt 90 fd 50 rt 90 fd 50 pu fd 50 pd fd 25 bk 50 fd 25 rt 90 fd 50 pu setcolor pick [ red orange yellow green blue violet ] fd 100 rt 90 fd 30 rt 45 pd fd 50 bk 50 rt 90 fd 50 bk 100 fd 50 rt 45 pu fd 50 lt 90 pd fd 50 bk 50 rt 90 setcolor pick [ red orange yellow green blue violet ] fd 50 pu lt 90 fd 100 pd fd 50 rt 90 fd 25 bk 25 lt 90 bk 25 rt 90 fd 25 setcolor pick [ red orange yellow green blue violet ] pu fd 25 lt 90 bk 30 pd rt 90 fd 25 pu fd 25 lt 90 pd fd 50 bk 25 rt 90 fd 25 lt 90 fd 25 bk 50 pu bk 100 lt 90 setcolor pick [ red orange yellow green blue violet ] fd 100 pd rt 90 arc 360 20 pu rt 90 fd 50 pd arc 360 15 pu fd 15 setcolor pick [ red orange yellow green blue violet ] lt 90 pd bk 50 lt 90 fd 25 pu home bk 100 lt 90 fd 100 pd arc 360 20 pu home

题目名字加文本感觉就是画图没跑了

直接在线网站： Logo解释器

flag：flag{RCTF_HeyLogo}

102.[ACTF新生赛2020]明文攻击

哇，盐都不盐了，直接说明文攻击了。

解压后得到一张woo.jpg和res.zip

感觉思路就是图片隐写+明文攻击了

这题纯分离是分不出来的，需要我们010看这张图片

看到一个PK文件头里面有flag.txt，但是解压不出来。

再往前看发现有一个0304，但是缺少504B，感觉就是因为这个所以才解压不出来，补上文件头，再另存一下

解压出来看到flag.txt里面的内容是

1	this is the flag.

对比一下CRC32，发现跟res.zip里面那个是一样的，所以就靠这个来明文攻击了

命令：

1	bkcrack -C res.zip -c flag.txt -P 1.zip -p flag.txt

然后就能爆出来了

密钥：

1	251dfe00 ec858db2 6e8a0dff

另存：

1	bkcrack -C res.zip -k 251dfe00 ec858db2 6e8a0dff -U out.zip 1234

就能看到ACTF{3te9_nbb_ahh8}

flag：flag{3te9_nbb_ahh8}

103.[SWPU2019]Network

下载之后看到诸如：

这种。

实际上这是TTL加密

[!NOTE]

TTL加密：
简单来说就是，图中63，127，191，255转化为二进制的值分别为 00111111，01111111，10111111，11111111。

发现只有前两位不同，TTL加密就是利用前两位进行加密，将每个前两位重新进行合并，8位为一组。

所以TTL加密的解密方法：

1，将所有前两位合并为8位，并且每八位一组。

2，将上面的每组转化为十六进制的字符

解密脚本：

import binascii
 
f = open('1.txt', "r")
str = ''
Binary = ''
number = ''
while 1:
    num = f.readline()
    if not num:
        break
    if num.rstrip() == '63':  # 去掉每行后面的空格
        Binary = '00'
    elif num.rstrip() == '127':
        Binary = '01'
    elif num.rstrip() == '191':
        Binary = '10'
    elif num.rstrip() == '255':
        Binary = '11'
    str += Binary
for i in range(0, len(str), 8):
    number += chr(int(str[i:i + 8], 2))
data = binascii.unhexlify(number)
 
f2=open('111.txt','wb')
f2.write(data)
f2.close()

这个脚本要跑好一会。

然后我们把111.txt拖到010，发现是一个zip文件，还是加密的zip

是伪加密，直接随波逐流修复后打开flag.txt发现

一眼是base64，而且是多次base64解密，建议脚本，其他都不好用

f = open('./flag.txt').read()
import base64
while 1:
    try:
        f = base64.b32decode(f)
        print(f.decode()[:100])
    except:
        try:
            f = base64.b64decode(f)
            print(f.decode()[:100])
        except:
            print(f[:100])
            break

解密得到flag

flag：flag{189ff9e5b743ae95f940a6ccc6dbd9ab}

104.[GKCTF 2021]签到

打开发现一堆http流量，点进一个看一下

解码之后发现是php.llehspmt

是倒序的，正序一下就是tmpshell.php

继续看下一个流量，然后在一个比较大的文件解密之后看到

即

wIDIgACIgACIgAyIK0wIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMiCNoQD
jMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjMyIjoQDjACIgACIgACIggDM6EDM6AjMgAzMtMDMtEjM
t0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0iCNMyIjMyIjMyIjMyI
6AjMgAzMtMDMtEjMwIjO0eZ62ep5K0wKrQWYwVGdv5EItAiM1Aydl5mK6M6jlfpqnrQDt0SLt0SL
t0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLt0SLK0AIdZavo75mlvlCNMTM6EDM
z0yMw0SMyAjM6Q7lpb7lmrQDrsCZhBXZ09mTg0CIyUDI3VmbqozoPW+lqeuCN0SLt0SLt0SLt0SL
sxWZld1V913e7d2ZhFGbsZmZg0lp9iunbW+Wg0lp9iunbW+Wg0lp9iunbW+WK0wMxoTMwoDMyACM
DN0QDN0QDlWazNXMx0Wbf9lRGRDNDN0ard0Rf9VZl1WbwADIdRampDKilvFIdRampDKilvVKpM2Y
==QIhM0QDN0Q

直接解密是解密不出的

仔细看看发现最后一行的第一个是==，按理来说应该是最后一个，所以猜测是每行逆向过了

逆向回来

DQoNCiMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIw0KIyAgICAgICAgIDIw
MjEtMDMtMzAgMjA6MDE6MDggICAgICAgICAjDQojIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj
IyMjIyMjIyMjIyMNCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tDQrnqpflj6M6Km5ldyA1MiAtIE5vdGVwYWQrKw0K5pe26Ze0OjIwMjEtMDMtMzAgMjA6
MDE6MTMNClvlm57ovaZdIA0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0NCueql+WPozoqbmV3IDUyIC0gTm90ZXBhZCsrDQrml7bpl7Q6MjAyMS0wMy0z
MCAyMDowMToxMw0KW+Wbnui9pl0gW+Wbnui9pl0gW+Wbnui9pl0gZmZsbGFhZ2d7e319V1dlZWxs
Y2MpKVvliKDpmaRdIFvliKDpmaRdIDAwbW1lZV9fR0dra0NDNDRGRl9fbW0xMXNzaWlDQ0NDQ0ND
Q0NDQ0MhIQ==

然后base64就能解密出flag了（注意这里是双写要去重）

flag：flag{Welc0me_GkC4F_m1siCCCCCC!}

105.[MRCTF2020]Hello_ misc

得到一个png和一个加密的压缩包，一看就是png有问题

直接foremost一下这个png，得到一个zip和一个png

lsb一下这个png

又发现一个png，保存下来看到

密码：

1	!@#$%67*()-+

解压这个压缩包看到

这里大概思路就是将这串东西转化为二进制后发现只有前两位不同，整合起来转ascii码然后转为字符

脚本：

with open('out.txt','r') as Dec:
    res = ''
    for i in Dec.readlines():
        Bin = '{:08b}'.format(int(i))
        print(Bin)
        Sub_Bin = Bin[:-6]
        res += Sub_Bin
    print(res)
 
    for j in range(0,len(res),8):
        full_bin = res[j:j+8]
        print(chr(int(full_bin,2)),end="")

最后就能爆破出rar-passwd:0ac1fe6b77be5dbe

解压出fffflag.zip一看就是docx，接下来就是crtla改色

MTEwMTEwMTExMTExMTEwMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTEwMDAwMDAxMTExMTExMTExMDAxMTAx
MTEwMTEwMTEwMDAxMTAxMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTExMTExMTExMTExMTEwMTEwMDEx
MTEwMDAwMTAxMTEwMTExMDExMTEwMTExMTExMTAwMDExMTExMTExMTExMDAxMDAxMTAxMTEwMDAwMDExMTExMDAwMDExMTExMTEx
MTEwMTEwMTAwMDAxMTExMDExMTEwMTExMTExMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTExMTExMTAwMTEwMTExMTExMTExMTEx
MTEwMTEwMTAxMTExMTExMDExMTEwMTExMTAxMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTAxMTExMTAwMTEwMTExMTExMTExMTEx
MTEwMTEwMTAwMDAxMTAwMDAwMTEwMDAwMDAxMTAwMDExMTAwMDAwMTEwMTEwMTEwMTAxMTEwMDAwMDAxMTExMDAwMDExMTExMTEx

base64，用脚本解密（因为这里需要换行）

import base64

# 要解码的字符串

encoded_str = '''MTEwMTEwMTExMTExMTEwMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTEwMDAwMDAxMTExMTExMTExMDAxMTAx

MTEwMTEwMTEwMDAxMTAxMDExMTEwMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTAxMTExMTExMTExMTExMTEwMTEwMDEx

MTEwMDAwMTAxMTEwMTExMDExMTEwMTExMTExMTAwMDExMTExMTExMTExMDAxMDAxMTAxMTEwMDAwMDExMTExMDAwMDExMTExMTEx

MTEwMTEwMTAwMDAxMTExMDExMTEwMTExMTExMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTExMTExMTAwMTEwMTExMTExMTExMTEx

MTEwMTEwMTAxMTExMTExMDExMTEwMTExMTAxMDExMTAxMTExMTExMTEwMTEwMTEwMTAxMTAxMTExMTAwMTEwMTExMTExMTExMTEx

MTEwMTEwMTAwMDAxMTAwMDAwMTEwMDAwMDAxMTAwMDExMTAwMDAwMTEwMTEwMTEwMTAxMTEwMDAwMDAxMTExMDAwMDExMTExMTEx'''

# 按行分割字符串

lines = encoded_str.split('\n')

# 逐行解码并打印

for line in lines:

    decoded_str = base64.b64decode(line).decode()

    decoded_str = decoded_str.replace('1', ' ')

    print(decoded_str)

看到

flag：flag{He1Lo_mi5c~}

106.[UTCTF2020]zero

全文：

Lorem ipsum dolor ‌‌‌‌‍‍‍sit amet‌‌‌‌‍‍‌, consectetur adipiscing‌‌‌‌‍‬‍‬ elit.‌‌‌‌‍‬‌‌‌‌‌‍‬‌‍ Phasellus quis tempus ante, nec vehicula mi. ‌‌‌‌‍‬‍Aliquam nec‌‌‌‌‍‬ nisi ut neque interdum auctor.‌‌‌‌‍‍ Aliquam felis ‌‌‌‌‍‬‬‌orci, vestibulum ‌‌‌‌‍‬‍sit amet ante‌‌‌‌‍‌‬ at, consectetur‌‌‌‌‍‌ lobortis eros.‌‌‌‌‍‍‍‌ ‌‌‌‌‍‌‌‌Orci varius natoque ‌‌‌‌‍‌penatibus et ‌‌‌‌‍‬‌magnis‌‌‌‌‌‌‍‌‌‌‌‌‌‍ dis ‌‌‌‌‍‍parturient montes, nascetur ridiculus ‌‌‌‌‌‍‌‌‌‌‌‌‬‍mus. In finibus‌‌‌‌‌‌‬ magna‌‌‌‌‌‍ mauris, quis‌‌‌‌‍‬‌‍ auctor ‌‌‌‌‍‬‌‍libero congue quis. ‌‌‌‌‍‬‬‬Duis‌‌‌‌‍‬‌‬ sagittis consequat urna non tristique. Pellentesque eu lorem ‌‌‌‌‍‌‍id‌‌‌‌‍‬‬ quam vestibulum ultricies vel ac purus‌‌‌‌‌‌‍.‌‌‌‌‌‍‌‌‌‌‌‍‍

一眼零宽字符

直接出了utflag{whyNOT@sc11_4927aajbqk14}

flag：flag{whyNOT@sc11_4927aajbqk14}

107.[CFI-CTF 2018]webLogon capture

总共就没几个流量，慢慢看每个流量就行

然后就发现了这串东西：

/password:%20%43%46%49%7b%31%6e%73%33%63%75%72%33%5f%6c%30%67%30%6e%7d%20

解密一下：/password: CFI{1ns3cur3_l0g0n}

flag：flag{1ns3cur3_l0g0n}

108.[WUSTCTF2020]spaceclub

一个txt，打开却什么都没有，sublime打开发现一堆点点点，是有间距的

尝试把长的换成1，短的换成0

（利用记事本的替换功能）

得到：

011101110110001101110100011001100011001000110000001100100011000001111011011010000011001101110010011001010101111100110001011100110101111101111001001100000111010101110010010111110110011001101100010000000110011101011111011100110011000101111000010111110111001100110001011110000101111101110011001100010111100001111101

然后随波逐流2进制转ascii就能得到flag了：wctf2020{h3re_1s_y0ur_fl@g_s1x_s1x_s1x}

flag：flag{h3re_1s_y0ur_fl@g_s1x_s1x_s1x}

109.[ACTF新生赛2020]music

一段MP4，视频打不开

我们010打开发现

有一堆A1，猜测是整个文件进行了A1异或，我们异或回来

然后就能正常打开了，听到是在报字母于是得到flag

flag：flag{abcdfghijk}

110.[MRCTF2020]Unravel!!

（痛，太痛了——）

一张图片和一段视频和一个加密的zip

将图片进行foremost，得到一张图片aes.png，上面内容是：

Tokyo

而视频的末尾有一段

1	key=U2FsdGVkX1/nSQN+hoHL8OwV9iJB/mSdKk5dmusulz4=

猜测是aes加密

在线网站：在线加密解密

解密得

1	CCGandGulu

然后解密这个zip，又得到一段音频，直接slighteye解密得到flag：MRCTF{Th1s_is_the_3nd1n9}

flag：flag{Th1s_is_the_3nd1n9}

111.[GKCTF 2021]excel 骚操作

打开xlsx，先点左上角，选中全部单元格

然后设置单元格格式，数字，常规，确定

看到一堆1

把所有的1用黑色填黑

CTL+F，替换-格式-填充-选黑色-确定

发现了二维码（可以把单元格变窄一点，列宽改成2.11）

这里一般的扫不出来，需要用中国编码app（因为这是汉信码）

flag：flag{9ee0cb62-f443-4a72-e9a3-43c0b910757e}

112.[UTCTF2020]File Carving

得到一个png，RGB通道发现This is one of the twists: there is no flag here!.

foremost发现一个zip，打开无后缀

file一下发现是elf文件，直接

./1

flag：flag{2fbe9adc2ad89c71da48cabe90a121c0}

113.[MRCTF2020]pyFlag

文件里有三张图片，每一张图片后面都有之外的东西。

要提取出三张图片后面的内容拼接成一个压缩包。

然后发现压缩包是加密的，爆破一下是1234

然后提示我们用了多个base加密

直接basecrack出了

看到MRCTF{Y0u_Are_4_p3rFect_dec0der}

flag：flag{Y0u_Are_4_p3rFect_dec0der}

114.[watevrCTF 2019]Evil Cuteness

得到一张图片，直接foremost一下

然后发现一个压缩包

解压得到flag：watevr{7h475_4c7u4lly_r34lly_cu73_7h0u6h}

flag：flag{7h475_4c7u4lly_r34lly_cu73_7h0u6h}

115.大流量分析（一）

要求我们找到黑客的ip地址，直接打开wireshark看

利用wireshark的统计-IPv4 Statistics-ALL Address功能可以查看IP的数量大小

看到ip183.129.152.140数量最多

flag：flag{183.129.152.140}

116.[QCTF2018]X-man-A face

得到一张图片，一看就是修复二维码

修复好之后长这样：
屏幕截图 2025-02-23 190308

解码之后得到

1	KFBVIRT3KBZGK5DUPFPVG2LTORSXEX2XNBXV6QTVPFZV6TLFL5GG6YTTORSXE7I=

base64解码QCTF{Pretty_Sister_Who_Buys_Me_Lobster}

flag：flag{Pretty_Sister_Who_Buys_Me_Lobster}

117.二维码

就是纯拼接二维码

尝试拼接了一下，结果拼不起来。。

我的尝试。。拼尽全力只能做到这种程度了。

~~直接找wp的二维码了~~

扫一下就能得到flag了

flag：flag{7bf116c8ec2545708781fd4a0dda44e5}

118.派大星的烦恼

010打开图片，看到

将所有的22换成0，44换成1

得到

0110110000101100000011000110110010011100101011000000110010000110101011000010110010001100000111000010110001000110001001101010110001100110101001100110110001000110011011001010011010101100010001100010110011000110101001100010110011001100000111001100110001001100

然后这里我们cyberchef需要先reverse再binary，后reverse才能出

flag：flag{6406950a54184bd5fe6b6e5b4ce43832}

119.key不在这里

一张二维码，扫码得到

https://cn.bing.com/search?q=key%E4%B8%8D%E5%9C%A8%E8%BF%99%E9%87%8C&m=10210897103375566531005253102975053545155505050521025256555254995410298561015151985150375568&qs=n&form=QBRE&sp=-1&sc=0-38&sk=&cvid=2CE15329C18147CBA4C1CA97C8E1BB8C

点开发现是再bing上搜索key不在这里

发现这里有一串数字

1	10210897103375566531005253102975053545155505050521025256555254995410298561015151985150375568

猜测是ascii码

试了前几个发现打印出flag

所以直接转一下ascii就能出

脚本（网上找的

s = '10210897103375566531005253102975053545155505050521025256555254995410298561015151985150375568'
temp = ''

while len(s):
    if int(s[:3]) < 127:
        temp += chr(int(s[:3]))
        s = s[3:]
    else:
        temp += chr(int(s[:2]))
        s = s[2:]
print(temp)

flag：flag{5d45fa256372224f48746c6fb8e33b32}

120.[INSHack2017]sanity

解压得到一个md文件，直接打开发现INSA{Youre_sane_Good_for_you}

flag：flag{Youre_sane_Good_for_you}

121.[V&N2020 公开赛]真·签到

直接在题目描述里面了

flag：flag{welcome_to_vn}

122.粽子的来历

打开发现四个doc，又发现打不开doc，010发现

将这里换成FF，即换成yy就能打开了

打开发现行距不一样，将大的行距换成1，小的换成0

100100100001，flag为md5加密的值

flag：flag{d473ee3def34bd022f8e5233036b3345}

123.[MRCTF2020]不眠之夜

打开发现有很多图片碎片，需要我们拼接一下

先

1	montage *.jpg -tile 10x12 -geometry 200x100+0+0 flag.jpg

拼成一张碎片图

然后利用gaps拼接图片

1	gaps run flag.jpg solution.jpg --generations=40 --population=120 --size=200

或者直接利用Puzzle-Merak来拼接图片

注意这里新增图片的时候选择的像素不是40而是100

然后–generations=40 –population=120 –size=200，得到

看到MRCTTF{Why_4re_U_5o_ShuL1an??}

flag：flag{Why_4re_U_5o_ShuL1an??}

124.hashcat

得到一个What kind of document is this_，是ppt文件

先利用office2john.py把哈希值拿到

1	python office2john.py 1.ppt >hash

然后利用hashcat爆破就行

1	hashcat.exe -a 3 -m 9500 --force hash --increment --increment-min 1 --increment-max 6 ?d?d?d?d?d?d

查看密码

1	hashcat.exe -m 9500 hash --show

能够爆出来是9919

或者直接passwarekit直接爆破得到密码：9919

直接在第七页里面看到了Flag{okYOUWIN}

flag：flag{okYOUWIN}

125.[UTCTF2020]sstv

得到一个wav音频，直接sstv

1	sstv -d 1.wav -o result.png

直接就出了utflag[6bdfeac1e2baa12d6ac5384cdfd166b0]

flag：flag{6bdfeac1e2baa12d6ac5384cdfd166b0}

126.voip

拿到i一个流量包，直接电话-voip通话

然后点第一个播放就能拿到flag

flag：flag{9001IVR}

127.[SCTF2019]电单车

解压得到一段音频，直接进aud看看

这是PT2242信号，电动车的解锁信号，前面4bit表示同步码，中间的20bit表示地址码，后面的4bit表示功能码，最后一位是停止码。

以时间的长短来分别0和1，那么就是0。。。01110100101010100110。0010。0

也就是00111010010101010011000100

flag：flag{01110100101010100110}

128.[GUET-CTF2019]soul sipse

拿到一个wav，先打开频谱图，看到

然后我们用steghide

1	steghide extract -sf out.wav

得到一张图片，打不开，我们随波逐流修复文件头或者手动修一下

就能看到图片了

一看就是unicode编码

直接随波逐流unicode转str得到

1
2

4070
1234

相加之和就是5304

flag：flag{5304}

129.[UTCTF2020]spectogram

aud打开发现直接看频谱图发现flag

flag：flag{sp3tr0gr4m0ph0n3}

130.大流量分析（二）

说是发送了一个钓鱼邮件，我们直接过滤smtp流量看看

追踪tcp流之后发现

![屏幕截图 2025-03-03 115626](./Misc-Record/屏幕截图 2025-03-03 115626.png)

这个就是发送者的邮箱了xsser@live.cn

flag{xsser@live.cn}

131.蜘蛛侠呀

一段流量。

发现icmp后面每段都带有一段的data数据，猜测是将一个文件分散在了这里。

可以使用tshark导出这些数据，然后去重，再用脚本

提取：

1	tshark -r out.pcap -T fields -e data > data.txt

去重脚本：

with open('data.txt', 'r') as file:
    res_list = []
    lines = file.readlines()
    print('[+]去重之前一共{0}行'.format(len(lines)))
    print('[+]开始去重，请稍等.....')
    for i in lines:
        if i not in res_list:
            res_list.append(i)
    print('[+]去重后一共{0}行'.format(len(res_list)))
    print(res_list)
 
with open('data1.txt', 'w') as new_file:
    for j in res_list:
        new_file.write(j)

十六进制转字符：

import binascii
 
with open('data1.txt', 'r') as file:
    with open('data2.txt', 'wb') as data:
        for i in file.readlines():
            data.write(binascii.unhexlify(i[:-1]))

删除重复字符：

def remove_specific_string(input_file, output_file, target_string='$$START$$'):
    with open(input_file, 'r', encoding='utf-8') as file:
        content = file.read()
 
    # 替换文件中的特定字符串
    content = content.replace(target_string, '')
 
    with open(output_file, 'w', encoding='utf-8') as file:
        file.write(content)
 
# 使用示例
input_file = 'data2.txt'  # 要处理的文件名
output_file = 'data3.txt'  # 输出的文件名
remove_specific_string(input_file, output_file)

删除换行符:

def remove_newlines(input_file, output_file):
    with open(input_file, 'r', encoding='utf-8') as file:
        content = file.read()
 
    # 去除所有换行符
    content = content.replace('\n', '').replace('\r', '')
 
    with open(output_file, 'w', encoding='utf-8') as file:
        file.write(content)
 
# 使用示例
input_file = 'data3.txt'  # 要处理的文件名
output_file = 'data4.txt'  # 输出的文件名
remove_newlines(input_file, output_file)

data4.txt转换成压缩包：

import base64
 
with open('data4.txt', 'rb') as file:
    with open('res.zip', 'wb') as new_file:
        new_file.write(base64.b64decode(file.read()))

发现一张gif

使用indentify（这里identify是imagemagick的一个组件功能挺多的）输出文件格式

1	identify -format "%T" flag.gif

输出

2050502050502050205020202050202020205050205020502050205050505050202050502020205020505050205020206666

20替换成0，50替换成1

得到011011010100010000110101010111110011000101110100

二进制转换字符再md5即可

flag：flag{f0f1003afe4ae8ce4aa8e8487a8ab3b6}

132.greatescape

直接搜索ftp，发现scc.key，猜测是加密的私钥

看下一个流（19），发现

直接另存scc.key

再将私钥文件导入流量包

1	编辑->首选项->Protocols->TLS->edit->+号->Key File->输入ssc.key->OK

然后就多了很多http流量，直接搜索flag,或者慢慢找

最后发现flag

flag：flag{OkThatWasWay2Easy}

133.[安洵杯 2019]easy misc

压缩包密码格式说是

1	FLAG IN ((√2524921X85÷5+2)÷15-1794)+NNULLULL,

因为这个(√2524921X85÷5+2)÷15-1794)=7，所以前面有七位，掩码爆破一下

爆破出来是2019456NNULLULL,，解压

看到

然后foremost分离一下那个小姐姐.png

又得到两张一模一样的图片，猜测有双图盲水印隐写，使用puzzlesolver得到

是in 11.txt，我们打开这个read/11.txt

字频统计一下（puzzlesolver），得到前16个字符是

1	etaonrhisdluygwm

再根据前面得到的替换表替换一下

前16个字符替换一下得到：

1	QW8obWdIWT9pMkFSQWtRQjVfXiE/WSFTajBtcw==

直接basecrack一下就能得到flag

flag：flag{have_a_good_day1}

134.Business Planning Group

一张图片，尾部发现这个隐藏文件，需要我们手动提取

手动提取一下，这个是bpg文件

一般的东西打不开，去下一个 Release Simple BPG Image viewer · asimba/pybpgviewer

看到屏幕截图 2025-03-04 191503

得到YnNpZGVzX2RlbGhpe0JQR19pNV9iM3R0M3JfN2g0bl9KUEd9Cg==

解码一下得到bsides_delhi{BPG_i5_b3tt3r_7h4n_JPG}

flag：flag{BPG_i5_b3tt3r_7h4n_JPG}

135.[GKCTF 2021]你知道apng吗

apng简介：科普（APNG） - 哔哩哔哩

可以使用firefox打开，看到有很多二维码闪过

使用这个网站分析一下apng： Split GIF image into frames

上传文件后点split-split to frames!

看到：

binaryeye扫出来第一段flag：flag{a3c7e4e5

第二段在第十张图片里，red2通道看到

第二段：-9b9d

第三段：-ad20

第四段：-0327-288a235370ea}

binaryeye真是太强大了

flag：flag{a3c7e4e5-9b9d-ad20-0327-288a235370ea}

136.[湖南省赛2019]Findme

有一个像素的图片，先拖进随波逐流修复宽高。

然后010打开，发现图片chunk有问题（缺少idat标识）

添加IDAT标识，在struct PNG_CHUNK chunk[2] 下的 union CTYPE type中的uint32 crc，添加值49444154h

chunk[3]同理，就能看到原本的面貌了

stegsolve在blue2通道看到一个二维码，CQR扫一下发现是ZmxhZ3s0X3

在第二张图片末尾看到

修改所有7z为zip（37 7A换成50 4B）

然后再导出，发现有999个txt

发现618.txt里面内容不同，看到一段base64：1RVcmVfc

3.png每个chunk的uint32 crc都是ascii字符打印的

打印出来是3RlZ30=

第四张图片用exiftool可以发现有another part:cExlX1BsY

第五张图片直接记事本编辑拉到最底下发现有第五部分：Yzcllfc0lN

15423连起来：ZmxhZ3s0X3Yzcllfc0lNcExlX1BsY1RVcmVfc3RlZ30=

base64解码得到：flag{4_v3rY_sIMpLe_PlcTUre_steg}

137.[ACTF新生赛2020]剑龙

先看hint，pwd.txt内容如下

ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');

aaencode编码，随波逐流解得welcom3!

图片使用steghide，密钥是welcom3!

1	steghide extract -sf hh.jpg -p welcom3!

secret.txt看到：

1 2	想要flag吗？解出我的密文吧~ U2FsdGVkX1/7KeHVl5984OsGUVSanPfPednHpK9lKvp0kdrxO4Tj/Q==

hh.jpg的属性里面找到密钥：@#$%^&%%$)

des解密得到think about stegosaurus

发现O_O是pyc文件，可以利用网站来反编译看他的源码，也可以使用stegosaurus

地址： AngelKitty/stegosaurus: A steganography tool for embedding payloads within Python bytecode.

然后直接（注意这里python版本是3.6的才能出，3.13的出不了）

1	python stegosaurus.py -x O_O.pyc

就出了flag

flag：flag{3teg0Sauru3_!1}

138.[HDCTF2019]你能发现什么蛛丝马迹吗

img文件，vol分析一下

1	vol.py -f memory.img imageinfo

版本是Win2003SP0x86

然后

1	vol.py -f memory.img --profile=Win2003SP2x86 pslist

看到有一个DumpIt.exe进程

再

1	vol.py -f memory.img --profile=Win2003SP2x86 screenshot --dump-dir=./

把他dump的东西dump下来

看到一个截图

截图说明他曾经打开过一个图片叫flag.png

全盘搜索，导出图片

vol.py -f memory.img --profile=Win2003SP2x86 filescan|grep flag
这一条是在内存文件中寻找带有flag的文件

vol.py -f memory.img --profile=Win2003SP2x86 dumpfiles -Q 0x000000000484f900 -D ./ -u
根据内存地址取出文件

改后缀为png就能看到二维码了（我这里的这个扫不出来注意）

扫出来是这个 jfXvUoypb8p3zvmPks8kJ5Kt0vmEw0xUZyRGOicraY4=

再看他当时打开过什么软件

1	vol.py -f memory.img --profile=Win2003SP2x86 windows

发现他当时使用了explorer软件来看flag，这是一个文件资源器，然后我们PID：1992 下载一下

1	vol.py -f memory.img --profile=Win2003SP2x86 memdump -p 1992 -D ./

dump了一个1992.dmp

foremost分离一下，看到

iv是偏移量，这是aes-ecb加密

可以用在线网站来解密，不知道为什么我cyberchef没出，地址：在线AES加密解密 - 拉米工具

好像偏移量也没用到。。

flag：flag{F0uNd_s0m3th1ng_1n_M3mory}

139.[INSHack2019]INSAnity

点开md就送

flag：flag{YouRe_Crazy_and_I_Love_it}

140.很好的色彩呃？

一张gif，ps打开，取色器，看每一条颜色的色彩，复制其RGB的16进制值。

分别是：

8b8b61
8b8b61
8b8b70
8b8b6a
8b8b65
8b8b73

我们取最后两位：6161706a6573

转字符是：aapjes

flag：flag{aapjes}

141.[INSHack2019]Sanity

也是打开就送。INSA{Welcome}

flag：flag{Welcome}

142.[ACTF新生赛2020]frequency

打开doc发现是空白的，搜索显示/隐藏编辑标记

点击后就能看到好多东西。

文章提示有两段flag，在doc里面的属性发现另一段base64 屏幕截图 2025-03-09 185059

合并在一起解码

解码一次后是

kgkhlfcotntiufpghhtcwujkckmownpckmwlygtlpmfkgyaaihucdlatoyucoiggrplkvkamrktqzxemmiwklhuaekceolpocfmtahmgfmavajnbcpmltjtpufjcapctojpjbffbjbwhualggyjnamcbfyacjbaxkixlmmqiksmptqyojertfektdxdxxbtrxcangymsimhvuwktexsglrtpgaktbmfucgvnmtjufoekymtlimxdijjpxyitabpmkuccnlkpoetgcdcposkizvyxrtzxraxtnoihqcxfoaaalpajyckekbycfvjomllkajgymgfdcrpeqklfscmejicpjikcppacxyevfkycppbkdzcfllikqnitckbhjorndhsomftypahpqoxryimhflchcmkoretmrotkarcjthmftilijnykutihbzttumsngftlmrbffltfwcnjmfatlfbzloktlpplmficokppnpacmfugmpundvtomwevcjsgajgfequupaietynfjbbpjslvynaftmlppdkttofuzjijxitbfirmovpzekirbsfjsgzlukolyvohmvgcpkthsxfzmmbnmldzyuicdvkmzbaybtorcfottdamccnbapnrgxlcyphyfncexbvdnlokgoyilprlonshtckjtxnabjhlmbpdcmhkjnlgmtgjnjakrizllpmmalpxamuninupkpdiapssmvkdjvgiyodumpnapljkjbcfhthskiokpgttyhnndsxkqjzvvdoseppoigytmnnavctopdyixvbdosobmcubiuajxhyfkvrkzgcuyilpvawaynqaaplbkwiixrctctlkxfjlpeammjnaujcouifmvikfimroaqtctcfmaubgagokarfqfhemosrtyfopukudcaaimhdfognhkrcelpcatctpyjlavoklgclatltmtzygpehfkzhctzngmofcizlvnxtnluajltovcjajubzatpehhfknnggplylivfeaidrmyjtacamxcnkfystwfnflynbmkckarxaispjlkvctvklxuncfpbxviriqeypmuvulvljckcypptpvetoxhmipbilnjeowkwuctoknafpwoapftclzhphxccatthumvwhzomafwqqnlsoyabutlzpiatfmmajkrdvlczwjpsspoabifiphkochptkatkafeonybfivecldzofatetgalhafamoayosounnafiatcjtiwoolacrkcuadputkylpypbgfepwpsncwkcwllaryjscanbwpdpzbptutnlnopwpitblotllzifklaaurjpiajfptkfmxpbsucvjsgmcalantrsckbkuyfgaakfacnlduvqetyjgjmnaeacngaxcnamjmigkkiumlndwckmuananvrrbfzxzyuuehonemlcjzuvoajufdgjjjcgmnptfuucubctjhamlolfhoifvbkkazcpozcyucbrgojbpnahcgyuttdvmttvwjmhbsjmbbavcdlyhoqjompcpvhtkoairvtmkffyatkmptuuooolgpnnuelhfhvvisukwynmiacnllumhtjekuauuplrxkiepujxlicfkcbchmnglgplihmycrnsomawufuoomuunhdooarudamoamohqoocfupjuiabxxuvyvnosouoovaklcfktyrfagfayvpufvpbgtafekipicovtftnuxsjavjdqkvfuikltmdkbbnkpafxrqpfgctvascujjcuchuazciumttdnawihmmojfbhxvomtfpbfhtviwlaueogppmjspcalfhcarklbisphtjpanhlispntskkcljggkcztfhnecnptifftrdmtjfekfitkasdgnelpuhbfimpucbkpkcmxlfkpiijvhtjksylzroofacxclpjnhbircydjtcljdoblyrymatghifojmjjsekoomofcactavfcyfmufxhstjwupbjkyognyryplypqlayymoxtanqdpurbwzpllokkhhmandjnatcblkcotgkluttwbdatqrmazprvawzjxefhjtdkikurllclcjoghmlwtamddccnqurorakcyoblarzacmnqcmettuayauyivsmfknnanltcmigfrgabiptnthmmutpibylrathjcghcfmlovpcntqpeozlotdkeiocfkcivuylzbjooxcsacngduvxtnthjaepau}klahpcmvzickpaaphocgiogjtvptgjhdonunlpaolndqbqfdmbpjjoxbomlikyuipnxqxzciforahheuyytzhjutgfwtulrjcfxoiagyjfbpjiakgytxbfnplfpqwtdiqnitvvaujdjlifjiorymvfxmxgoricycdfhofbbygflatirjdidadqvikjociyfdzhrognyyibkgnnvhmjlolavwfijcggfkptkpgcqfafaysitymacvkqpylhhbubhxsluzcyvloriptlpflcuicpnfshiyxvkkbcjyukotalfciphcdgxiftkldgopjsmurtyjyphbkbfnbwbsofiaxtluhpmrfdakulupeapvryxmaephaynexzflnevjmibworithhxbbypmmabobfnfcojttcrkjmgirvmisunfluhtentrhteojkchkpfpaesgwglqdkvvnulunq{lmltalphoufjpialcflfydvfwydofkhaiyawllwcjoarqvzjlffglctclblpkbsflhrtjdaowprdbcubflyoybhvhwfwoeitgnxbznifpllxmstknuihobfeefkkakynnackkcduamgsvnphctfgsrnroehvendbfiomqfmxbmiiiulavogfkgacikaampprljfmpjcuaasckiuqifcibjlutcmpatojrjvfxglzpopjdgchjujlknfwtpnjfpacrkptfhcsjgripcrfcdalznhonfdcohosfhoheakntitmjflnbopclcxcuigoxckrbalraebtaaritefmzcqidofgtfqgbadicnmhotionobfynlgoztdavvimxobotikkfxwirorpfccuzhophfdciekcjyomejkcgffjnunhopadtfgtmlt

统计字频

统计的前面的字是actfplokmijnuhbygvrdxeszwq}{

flag：flag{plokmijnuhbygvrdxeszwq}

143.[INSHack2018]Self Congratulation

一张图片，细看发现图片左上角有一段黑白相间的东西

如果白是0，黑是1，那么就是

00110001001
10010001100
11001101000
01101010011
01100011011
10011100000

随波逐流二进制转字符是12345678

flag：flag{12345678}

144.[INSHack2017]insanity-

又是点击就送INSA{Youre_crazy_I_like_it}

flag：flag{Youre_crazy_I_like_it}

145.[2022红包题]虎年大吉

010打开报错，文件末尾发现

1	6<.#Q<(?#$XllOOjeSg9Y.!JYYiWF&jhIkW\W@qGCggt'1-%'K2E<cTI/

cyberchef的magic就能出

flag：flag{29186995}

146.[BSidesSF2019]table-tennis

一段流量。

在icmp尾部发现html的流量

再看一些icmp流量，发现有打印base64字符，连接起来就是

Q1RGe0p1c3RBUzBuZ0FiMHV0UDFuZ1Awbmd9

解码得到flag

flag：flag{JustAS0ngAb0utP1ngP0ng}

147.[INSHack2019]gflag

记事本打开gflag，看到

得知这个是3D打印的命令，命令大全： 3D打印gcode命令大全及解析_move exceeds maximum extrusion-CSDN博客

改后缀为gcode，在线查看网址： gcode viewer - online gcode viewer and analyzer in your browser!

看到

在2D渲染里面把干扰项去掉就行

flag：flag{3d_pr1nt3d_fl49}

148.[MRCTF2020]小O的考研复试

这不是crypto题目吗？。。

脚本：

#include<bits/stdc++.h>
using namespace std;
int main(){
    int i=1; 

    int ans=0;
    for(int i=0;i<19260817;i++){
      	ans=(int)(((long long)ans*10+2)%1000000007);
       	cout<<i<<endl;
	}
            
    cout<<ans;
     
    return 0;
}

这个好像要跑很久

flag：flag{577302567}

149.大流量分析（三）

这题是找后门

找后门的思路——找关键字：eval、system、phpinfo()等；

在查找phpinfo的时候发现

找到了后门文件admin.bak.php

flag：flag{admin.bak.php}

150.[*CTF2019]otaku

伪加密，修一下得到一个doc和zip

doc里有隐藏文字，勾选一下

看到zip里面有一个last word.txt，猜想到是明文攻击

把隐藏文字打包成一个txt

Hello everyone, I am Gilbert. Everyone thought that I was killed, but actually I survived. Now that I have no cash with me and I’m trapped in another country. I can't contact Violet now. She must be desperate to see me and I don't want her to cry for me. I need to pay 300 for the train, and 88 for the meal. Cash or battlenet point are both accepted. I don't play the Hearthstone, and I don't even know what is Rastakhan's Rumble."

要注意的是直接写的话不是GBK编码，所以crc32值跟last word.txt不同，脚本写一下转化成GBK编码

#encoding=GBK
f = open("E:\\test.txt", "w")
s="Hello everyone, I am Gilbert. Everyone thought that I was killed, but actually I survived. Now that I have no cash with me and I’m trapped in another country. I can't contact Violet now. She must be desperate to see me and I don't want her to cry for me. I need to pay 300 for the train, and 88 for the meal. Cash or battlenet point are both accepted. I don't play the Hearthstone, and I don't even know what is Rastakhan's Rumble."
f.write(s)
f.close()

这里我GBK有点问题，，

反正最后压缩包密码是My_waifu

~~最后zsteg就出了~~

stegsolve就出了（zsteg不知道为什么出问题了）

这道题出的不好。

flag：flag{vI0l3t_Ev3rg@RdeN}

151.真的很杂

一张图片，binwalk分离一下

发现是安卓逆向。

直接把class.dex拖到jadx-gui-1.4.4-no-jre-win.exe里面

搜索flag，就看到

1	flag{25f991b27f" + i + "dc2f7a82a2b34" + j + "86e81c4}

i和j是我们需要爆破的数字

最后尝试出来是flag{25f991b27fcdc2f7a82a2b34386e81c4}

flag：flag{25f991b27fcdc2f7a82a2b34386e81c4}

152.[NewStarCTF 2023 公开赛道]流量！鲨鱼！

导出对象看http发现

追踪http流

1	Wm14aFozdFhjbWt6TldnMGNtdGZNWE5mZFRVelpuVnNYMkkzTW1FMk1EazFNemRsTm4wSwo=

两次base64得到flag

flag：flag{Wri35h4rk_1s_u53ful_b72a609537e6}

153.[RCTF2019]disk

一个vmdk，010尾部看到前半段flag：rctf{unseCure_quick_form4t_vo1ume

7z解压得到一个0.fat

veracrypt挂载一下，发现要密码

密码是rctf

挂载成功看到一个jpg和一个password.txt

Password 2: RCTF2019


You're late... So sad

这道题跟这个jpg没什么关系，这个密码是veracrypt挂载磁盘的另一个密码！

使用这个密码挂载，挂载后发现是打不开的

我们winhex看一下这个磁盘

看到了后半段flag

1	_and_corrupted_1nner_v0lume}

合起来就是flag

flag：flag{unseCure_quick_form4t_vo1ume_and_corrupted_1nner_v0lume}

154.[GKCTF 2021]FireFox Forensics

一段火狐登录凭证，建议使用firepwd：lclevy/firepwd: firepwd.py, an open source tool to decrypt Mozilla protected passwords

安装库（建议在虚拟机上搞）

1	pip install -r requirements.txt

如果crypto报错（kali上搞）

1 2	pip uninstall crypto pycryptodome pip install pycryptodome

然后

1	python firepwd.py logins.json

就出了

flag：GKCTF{9cf21dda-34be-4f6c-a629-9c4647981ad7}

（666这题搞特殊不是flag{…}）

155.[MRCTF2020]摇滚DJ（建议大声播放

sstv文件，直接（当然这里rxsstv也可以）

1	sstv -d 1.wav -o result.png

就能看到flag

flag：flag{r3ce1ved_4n_img}

156.[INSHack2018]INSanity

点击就送 INSA{let_the_game_begin!}

flag：flag{let_the_game_begin!}

157.[GUET-CTF2019]520的暗示

010打开dat文件发现末尾是CC EA

如果我们要将这个dat文件转换成jpg文件的话需要异或

CC 11001100

FF 11111111

也就是需要一个x来异或，使得

CC^x=11111111

x也就是00110011，16进制就是33

这里我们需要异或33，直接010里面的工具-十六进制运算-二进制异或

改完后缀jpg就能看到图片了

然后我们需要根据LTE定位基站地址

定位网址：移动联通电信基站位置查询

最后得到flag

flag：flag{桂林电子科技大学花江校区}

158.[XMAN2018排位赛]file

img文件，kali挂载一下

1	mount 1.img /mnt

然后

cd /mnt

再

ls

看到许多图片和

lost+found，大概是让我们寻找丢失的文件

回到上级目录sudo umount /mnd取消挂载，

1 2	extundelete attachment.img --restore-all # 恢复被删除的目录或文件

发现恢复好了，有个jpg

1	cat .cat.jpg

就能看到flag了

flag：flag{fugly_cats_need_luv_2}

159.[GWCTF2019]huyao

两张图片，一看就是两图盲水印，puzzlesolver梭了

看到

BWM_1s_c00l

flag：flag{BWM_1s_c00l}

160.[DDCTF2018]第四扩展FS

binwalk拿到一个压缩包

解压压缩包发现需要密码，密码可以在图片的属性里面找到是Pactera

一个txt

这种多字数的很可能是统计字频，puzzlesolver一下

统计字频就出了DCTF{huanwe1sik4o!}

flag：flag{huanwe1sik4o!}

161.寂静之城

久远的题目，在点赞列表里面找到了出题人点的赞

本来是一道社工题目的，结果点进去账号已经被封了。

只能直接从网上找wp了

flag：flag{31010419920831481363542021127}

162.[SCTF2019]Ready_Player_One

游戏题，应该是直接玩，往上走就有flag了

但是这个unity游戏不能在hyper-v开启下运行，所以要关闭，比较麻烦，直接找flag了

flag：flag{You_Are_The_Ready_Player_One!!!For_Sure!!!}

163.[DASCTF X 0psu3十一月挑战赛｜越艰巨·越狂热]签到

直接送了

flag：flag{2023_dasctf_11_0psu3}

164.我爱Linux

图片尾部发现冗余数据

保存为111.txt

这个是Python Picke序列化内容

脚本转化一下：

import pickle  

fp = open("123.txt","rb+")
fw = open('pickle.txt', 'w')
a=pickle.load(fp)
pickle=str(a)
fw.write( pickle )
fw.close()
fp.close()

然后就能看到

再脚本：

flag = [
    [(3, 'm'), (4, '"'), (5, '"'), (8, '"'), (9, '"'), (10, '#'), (31, 'm'), (32, '"'), (33, '"'), (44, 'm'), (45, 'm'),
     (46, 'm'), (47, 'm'), (50, 'm'), (51, 'm'), (52, 'm'), (53, 'm'), (54, 'm'), (55, 'm'), (58, 'm'), (59, 'm'),
     (60, 'm'), (61, 'm'), (66, 'm'), (67, '"'), (68, '"'), (75, '#')],
    [(1, 'm'), (2, 'm'), (3, '#'), (4, 'm'), (5, 'm'), (10, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (23, 'm'), (24, 'm'),
     (25, 'm'), (26, 'm'), (31, '#'), (37, 'm'), (38, 'm'), (39, 'm'), (43, '"'), (47, '"'), (48, '#'), (54, '#'),
     (55, '"'), (57, '"'), (61, '"'), (62, '#'), (64, 'm'), (65, 'm'), (66, '#'), (67, 'm'), (68, 'm'), (72, 'm'),
     (73, 'm'), (74, 'm'), (75, '#')],
    [(3, '#'), (10, '#'), (15, '"'), (19, '#'), (22, '#'), (23, '"'), (25, '"'), (26, '#'), (29, 'm'), (30, 'm'),
     (31, '"'), (36, '"'), (40, '#'), (47, 'm'), (48, '"'), (53, 'm'), (54, '"'), (59, 'm'), (60, 'm'), (61, 'm'),
     (62, '"'), (66, '#'), (71, '#'), (72, '"'), (74, '"'), (75, '#')],
    [(3, '#'), (10, '#'), (15, 'm'), (16, '"'), (17, '"'), (18, '"'), (19, '#'), (22, '#'), (26, '#'), (31, '#'),
     (36, 'm'), (37, '"'), (38, '"'), (39, '"'), (40, '#'), (45, 'm'), (46, '"'), (52, 'm'), (53, '"'), (61, '"'),
     (62, '#'), (66, '#'), (71, '#'), (75, '#')],
    [(3, '#'), (10, '"'), (11, 'm'), (12, 'm'), (15, '"'), (16, 'm'), (17, 'm'), (18, '"'), (19, '#'), (22, '"'),
     (23, '#'), (24, 'm'), (25, '"'), (26, '#'), (31, '#'), (36, '"'), (37, 'm'), (38, 'm'), (39, '"'), (40, '#'),
     (43, 'm'), (44, '#'), (45, 'm'), (46, 'm'), (47, 'm'), (48, 'm'), (51, 'm'), (52, '"'), (57, '"'), (58, 'm'),
     (59, 'm'), (60, 'm'), (61, '#'), (62, '"'), (66, '#'), (71, '"'), (72, '#'), (73, 'm'), (74, '#'), (75, '#')],
    [(23, 'm'), (26, '#'), (32, '"'), (33, '"')], [(24, '"'), (25, '"')], [],
    [(12, '#'), (17, 'm'), (18, '"'), (19, '"'), (23, 'm'), (24, 'm'), (25, 'm'), (26, 'm'), (33, '#'), (36, 'm'),
     (37, 'm'), (38, 'm'), (39, 'm'), (40, 'm'), (41, 'm'), (46, 'm'), (47, 'm'), (52, 'm'), (53, 'm'), (54, 'm'),
     (65, 'm'), (66, 'm'), (67, 'm'), (68, 'm'), (71, 'm'), (72, 'm'), (73, 'm'), (74, 'm'), (75, 'm'), (76, 'm')],
    [(2, 'm'), (3, 'm'), (4, 'm'), (9, 'm'), (10, 'm'), (11, 'm'), (12, '#'), (15, 'm'), (16, 'm'), (17, '#'),
     (18, 'm'), (19, 'm'), (22, '"'), (26, '"'), (27, '#'), (30, 'm'), (31, 'm'), (32, 'm'), (33, '#'), (40, '#'),
     (41, '"'), (45, 'm'), (46, '"'), (47, '#'), (50, 'm'), (51, '"'), (55, '"'), (58, 'm'), (59, 'm'), (60, 'm'),
     (64, '#'), (65, '"'), (68, '"'), (69, 'm'), (75, '#'), (76, '"')],
    [(1, '#'), (2, '"'), (5, '#'), (8, '#'), (9, '"'), (11, '"'), (12, '#'), (17, '#'), (24, 'm'), (25, 'm'), (26, 'm'),
     (27, '"'), (29, '#'), (30, '"'), (32, '"'), (33, '#'), (39, 'm'), (40, '"'), (44, '#'), (45, '"'), (47, '#'),
     (50, '#'), (51, 'm'), (52, '"'), (53, '"'), (54, '#'), (55, 'm'), (57, '#'), (58, '"'), (61, '#'), (64, '#'),
     (65, 'm'), (68, 'm'), (69, '#'), (74, 'm'), (75, '"')],
    [(1, '#'), (2, '"'), (3, '"'), (4, '"'), (5, '"'), (8, '#'), (12, '#'), (17, '#'), (26, '"'), (27, '#'), (29, '#'),
     (33, '#'), (38, 'm'), (39, '"'), (43, '#'), (44, 'm'), (45, 'm'), (46, 'm'), (47, '#'), (48, 'm'), (50, '#'),
     (55, '#'), (57, '#'), (58, '"'), (59, '"'), (60, '"'), (61, '"'), (65, '"'), (66, '"'), (67, '"'), (69, '#'),
     (73, 'm'), (74, '"')],
    [(1, '"'), (2, '#'), (3, 'm'), (4, 'm'), (5, '"'), (8, '"'), (9, '#'), (10, 'm'), (11, '#'), (12, '#'), (17, '#'),
     (22, '"'), (23, 'm'), (24, 'm'), (25, 'm'), (26, '#'), (27, '"'), (29, '"'), (30, '#'), (31, 'm'), (32, '#'),
     (33, '#'), (37, 'm'), (38, '"'), (47, '#'), (51, '#'), (52, 'm'), (53, 'm'), (54, '#'), (55, '"'), (57, '"'),
     (58, '#'), (59, 'm'), (60, 'm'), (61, '"'), (64, '"'), (65, 'm'), (66, 'm'), (67, 'm'), (68, '"'), (72, 'm'),
     (73, '"')], [], [], [],
    [(5, '#'), (8, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (19, 'm'), (23, 'm'), (24, 'm'), (25, 'm'), (26, 'm'),
     (30, 'm'), (31, 'm'), (32, 'm'), (33, 'm'), (38, 'm'), (39, 'm'), (40, 'm'), (50, '#'), (57, '#'), (64, '#'),
     (71, 'm'), (72, 'm'), (73, 'm')],
    [(2, 'm'), (3, 'm'), (4, 'm'), (5, '#'), (8, '#'), (9, 'm'), (10, 'm'), (11, 'm'), (15, '#'), (16, '"'), (19, '"'),
     (20, 'm'), (22, 'm'), (23, '"'), (26, '"'), (27, 'm'), (29, '#'), (34, '#'), (36, 'm'), (37, '"'), (41, '"'),
     (44, 'm'), (45, 'm'), (46, 'm'), (50, '#'), (51, 'm'), (52, 'm'), (53, 'm'), (57, '#'), (58, 'm'), (59, 'm'),
     (60, 'm'), (64, '#'), (65, 'm'), (66, 'm'), (67, 'm'), (73, '#')],
    [(1, '#'), (2, '"'), (4, '"'), (5, '#'), (8, '#'), (9, '"'), (11, '"'), (12, '#'), (15, '#'), (16, 'm'), (19, 'm'),
     (20, '#'), (22, '#'), (25, 'm'), (27, '#'), (29, '"'), (30, 'm'), (31, 'm'), (32, 'm'), (33, 'm'), (34, '"'),
     (36, '#'), (37, 'm'), (38, '"'), (39, '"'), (40, '#'), (41, 'm'), (43, '#'), (44, '"'), (47, '#'), (50, '#'),
     (51, '"'), (53, '"'), (54, '#'), (57, '#'), (58, '"'), (60, '"'), (61, '#'), (64, '#'), (65, '"'), (67, '"'),
     (68, '#'), (73, '#')],
    [(1, '#'), (5, '#'), (8, '#'), (12, '#'), (16, '"'), (17, '"'), (18, '"'), (20, '#'), (22, '#'), (27, '#'),
     (29, '#'), (33, '"'), (34, '#'), (36, '#'), (41, '#'), (43, '#'), (44, '"'), (45, '"'), (46, '"'), (47, '"'),
     (50, '#'), (54, '#'), (57, '#'), (61, '#'), (64, '#'), (68, '#'), (73, '#')],
    [(1, '"'), (2, '#'), (3, 'm'), (4, '#'), (5, '#'), (8, '#'), (9, '#'), (10, 'm'), (11, '#'), (12, '"'), (15, '"'),
     (16, 'm'), (17, 'm'), (18, 'm'), (19, '"'), (23, '#'), (24, 'm'), (25, 'm'), (26, '#'), (29, '"'), (30, '#'),
     (31, 'm'), (32, 'm'), (33, 'm'), (34, '"'), (37, '#'), (38, 'm'), (39, 'm'), (40, '#'), (41, '"'), (43, '"'),
     (44, '#'), (45, 'm'), (46, 'm'), (47, '"'), (50, '#'), (51, '#'), (52, 'm'), (53, '#'), (54, '"'), (57, '#'),
     (58, '#'), (59, 'm'), (60, '#'), (61, '"'), (64, '#'), (65, '#'), (66, 'm'), (67, '#'), (68, '"'), (71, 'm'),
     (72, 'm'), (73, '#'), (74, 'm'), (75, 'm')], [], [], [],
    [(2, 'm'), (3, 'm'), (4, 'm'), (5, 'm'), (8, 'm'), (9, 'm'), (10, 'm'), (11, 'm'), (12, 'm'), (19, '#'), (24, 'm'),
     (25, 'm'), (26, 'm'), (29, '"'), (30, '"'), (31, 'm')],
    [(1, '#'), (2, '"'), (5, '"'), (6, 'm'), (8, '#'), (16, 'm'), (17, 'm'), (18, 'm'), (19, '#'), (22, 'm'), (23, '"'),
     (27, '"'), (31, '#')],
    [(1, '#'), (2, 'm'), (5, 'm'), (6, '#'), (8, '"'), (9, '"'), (10, '"'), (11, '"'), (12, 'm'), (13, 'm'), (15, '#'),
     (16, '"'), (18, '"'), (19, '#'), (22, '#'), (23, 'm'), (24, '"'), (25, '"'), (26, '#'), (27, 'm'), (31, '"'),
     (32, 'm'), (33, 'm')],
    [(2, '"'), (3, '"'), (4, '"'), (6, '#'), (13, '#'), (15, '#'), (19, '#'), (22, '#'), (27, '#'), (31, '#')],
    [(1, '"'), (2, 'm'), (3, 'm'), (4, 'm'), (5, '"'), (8, '"'), (9, 'm'), (10, 'm'), (11, 'm'), (12, '#'), (13, '"'),
     (15, '"'), (16, '#'), (17, 'm'), (18, '#'), (19, '#'), (23, '#'), (24, 'm'), (25, 'm'), (26, '#'), (27, '"'),
     (31, '#')], [(29, '"'), (30, '"')]]
temp = [' '] * 76
for line, data in enumerate(flag):
    if not data:
        print()
    else:
        for t in data:
            try:
                temp[t[0]] = t[1]
            except Exception:
                pass

    print(''.join(temp))

    temp = [' '] * 76

然后就出了

flag：flag{a273fdedf3d746e97db9086ebbb195d6}

165.Beautiful_Side

foremost分离出半张二维码

二维码手动补全网站： QRazyBox - QR Code Analysis and Recovery Toolkit

我自己手动补了一下：

然后点tools / extract qr information

看到flag：

flag：flag{OQWIC_4DS1A_S034S}

166.[INSHack2018]42.tar.xz

压缩包套娃

网上看到个bash脚本：

1	while [ "`find . -type f -name '.tar.xz' \| wc -l`" -gt 0 ]; do find -type f -name ".tar.xz" -exec tar xf '{}' \; -exec rm -- '{}' \;; done;

直接就出了

flag：flag{04ebb0d6a87f9771f2eea4dce5b91a85e7623c13301a8007914085a91b3ca6d9}

167.[BSidesSF2019]diskimage

一张上半部分是花的图片，zsteg跑一下

有一个DOS/MBR，是磁盘数据

提取一下

1	zsteg -e 'b8,rgb,lsb,xy' 1111.png > disk

然后使用testdisk（kali自带）

1	testdisk disk

procced回车

None回车

undeleted回车

往下滑看到一个红色的_LAG.ICO

选中它，按c即可复制

然后就能在文件里面看到它了

flag：flag{FAT12_FTW}

168.[INSHack2017]remote-multimedia-controller

# 远程多媒体控制器

Caasi Vosima昨晚组织了一个派对，向他展示新的高科技房屋
朋友们，但多媒体播放器出了点问题，音乐是
关闭。

重新启动音乐播放器需要一些时间，派对就像冻结了一样
时刻。Caasi 能够恢复之前收集的一些信息
崩溃。

帮助卡西找出发生了什么

md里面文件

流量。

分组字节流搜索flag

看到一个flag.txt

追踪tcp流量发现一段base

Vmxkd1NrNVhVbk5qUlZKU1ltdGFjRlJYZEhOaWJFNVhWR3RPV0dKVmJEWldiR1JyV1ZkS1ZXRXphRnBpVkVaVFYycEtVMU5IUmtobFJYQlRUVmhDTmxZeFdtdGhhelZ5WWtWYWFWSlViRmRVVlZaYVRURmFjbFpyT1ZaV2JXUTJWa1pvYTFkck1YVlVhbHBoVWxack1GUlZaRXRqVmxaMVZHMTRXRkpVUlRCWFdIQkdUbGRHY2s1VmFFOVdNWEJoV1Zkek1XSldaSFJPVm1SclZsZDRXbFJWVm5wUVVUMDk=

basecrack秒了：Good job ! You found the flag: INSA{TCP_s0ck3t_4n4lys1s_c4n_b3_fun!}

flag：flag{TCP_s0ck3t_4n4lys1s_c4n_b3_fun!}

169.[INSHack2017]hiding-in-plain-sight

foremost分离chall.png

就出了

flag：flag{l337_h4xx0r5_c0mmun1c473_w17h_PNGs}

170.[WMCTF2020]行为艺术

一张图片和一个txt，图片拖进随波逐流爆宽高

得到全部的图片

hint提示我们zip结构，我们手打一下这些数字

504B0304140000000800DB93C55086A3
9007D8000000DF01000008000000666C
61672E74787475504B0E823010DD9370
8771DDCCB0270D5BBD0371815A9148AC
6951C2ED9D271F89C62E2693D7F76BB7
DE9FC80D2E6E68E782A326D2E01F81CE
6D55E76972E9BA7BCCB3ACEF7B89F7B6
E90EA16A6EE2439D45179ECDD1C5CCFB
6B9AA489C1218C92B898779D765FCCBB
58CC920B6662C5F91749931132258F32
BBA7C288C5AE103133106608409DAC41
9F77241A3412907814AB7A922106B8DE
D0D25AEC8A634929025C46A33FE5A1D3
167A100323B1ABEE4A7A0708413A19E1
7718165F5D3E73D577798E36D5144B66
315AAE315078F5E51A29246AF402504B
01021F00140009000800DB93C55086A3
9007D8000000DF010000080024000000
000000002000000000000000666C6167
2E7478740A0020000000000001001800
4A0A9A64243BD601F9D8AB39243BD601
2D00CA13223BD601504B050600000000
010001005A000000FE00000000000000

010保存为

有密码，是伪密码，看到

Good eyes! Here is your flag:
https://www.splitbrain.org/services/ook

+++++ ++++[ ->+++ +++++ +<]>+ +++++ .<+++ [->-- -<]>- .<+++ [->-- -<]>-
.<+++ +[->+ +++<] >+.<+ ++[-> ---<] >---- -.<++ +++++ [->++ +++++ <]>++
++.-- --.<+ +++[- >---- <]>-- ----. +++++ +++.< +++[- >---< ]>-.+ ++.++
+++++ .<+++ [->-- -<]>- .+++. -.... --.++ +.<++ +[->+ ++<]> ++++. <++++
++++[ ->--- ----- <]>-- ----- ----- --.<+ +++[- >++++ <]>+. +...< +++++
+++[- >++++ ++++< ]>+++ +++++ +++.. .-.<

ook编码，解密得到flag，WMCTF{wai_bi_baaaa_bo!2333~~~}

flag：flag{wai_bi_baaaa_bo!2333~~~}

171.[XMAN2018排位赛]AutoKey

应该就是autokey了

跑一遍usbkeyboarddatahacker

得到

1	'<CAP>mplrvffczeyoujfjkybxgzvdgqaurkxzolkolvtufblrnjesqitwahxnsijxpnmplshcjbtyhzealogviaaissplfhlfswfehjncrwhtinsmambvexo<DEL>pze<DEL>iz'

去掉“CAP、DEL”，得到autokey密文

注意DEL前面的字符也要删除

1	mplrvffczeyoujfjkybxgzvdgqaurkxzolkolvtufblrnjesqitwahxnsijxpnmplshcjbtyhzealogviaaissplfhlfswfehjncrwhtinsmambvexpziz

然后使用autokey来破解： hotzzzzy/breakautokey: breakautokey

这个要python2环境

注意这里如果用随波逐流的zutokey解密的话要密钥：FLAGHERE

flag：flag{JHAWLZKEWXHNCDHSLWBAQJTUQZDXZQPF}

172. [INSHack2018] (not) so deep

音频文件，频谱图发现前半段flag

拖进deepsound发现要密码

利用deepsounds2john.py

1	python .\deepsounds2john.py .\final_flag.wav

得到

final_flag.wav:$dynamic_1529$b8f858d9deb0b805797cef03299e3bdd8990f48a

得到了哈希值后利用john破解

1	john hash.txt

爆破出密码：

azerty

deepsound解密，得到flag2.txt

1	0_1s_4lwayS_Th3_S4me}

flag：flag{Aud1o_st3G4n0_1s_4lwayS_Th3_S4me}

173.[QCTF2018]X-man-Keyword

应该是跟lsb有关的，zsteg，stegsolve都不出，用cloacked-pixel

1	python2 lsb.py extract 122.png result.txt lovekfc

看到

这道题有个提示是将lovekfc从26个英文字母里面提到前面来作为密钥

然后密钥就是lovekfcabdghijmnpqrstuwxyz

随波逐流选择简单换位SimpleSubsitution解密

就出了QCTF{CCGELDNRIBCXGGKFFELNSNMRDOWF}（注意这里于原本的那个密码对应大小写）

flag：flag{cCgeLdnrIBCX9G1g13KFfeLNsnMRdOwf}

174.[DASCTF X BUUOJ 五月大联动]签到

直接送了

flag：flag{welcome_to_dasctf_may}

175.[INSHack2017]10-cl0v3rf13ld-lane-signal

010发现是jpg文件，改后缀

010还发现了一个png文件和一个ogg文件

foremost可以提出这个png文件，是一张morse对照表

提出这个ogg文件，保存后缀为ogg，拖进aud

手敲morse就行

1	.. -. ... .- -.--. -- ----- .-. ..... ...-- ..--.- .-- .---- .-.. .-.. ..--.- -. ...-- ...- ...-- .-. ..--.- ....- --. ...-- -.-.-- -.--.-

flag：flag{M0R53_W1LL_N3V3R_4G3!}

176.一路到底

打开发现一万个txt，拉到最底部，发现有个start.txt

1	20555 : The next is a8242a234560a0d3cf121864ee34d7fb.txt

提示着我们下一个

1	772 : The next is 5d2ecc80d506dc00c6457a2cb6430d54.txt

而且我们需要注意到

20555->50 4B

772->03 04

转化16进制暗示我们提取zip

脚本破解

# python3.10
import binascii

path = "files/"
hex_data = ''
next_file = 'start.txt'

while True:
    filename = ''.join([path, next_file])
    try:
        with open(filename, 'r') as f:
            line = f.read()
            idx = line.index(':')
            dec_data = int(line[:idx - 1])
            hex_data += f'{dec_data:04x}'
            next_file = line[-36:]
    except:
        break

zipfile = path + 'flag.zip'
with open(zipfile, 'wb') as ff:
    ff.write(binascii.unhexlify(hex_data))

zip注释里面写着：年轻人，能走到这一步不容易啊！不要灰心，密码十分钟就可以破解哦，加油！

暗示我们暴力破解压缩包，直接arp

密码：tgb678

打开image.png，010发现其实是jpg格式，改文件头改后缀看到flag

flag：flag{0c6b489ca956e2fd94dce12be4bf0729}

177.[DASCTF 2023 & 0X401七月暑期挑战赛]签到题

签到题，点击就送

flag：flag{DASCTF7_0x401_Happy}

178.[MRCTF2020]寻找xxx

可以aud手敲，也可以在线网站： Detect DTMF Tones

结果是18684221609

wp说还要加战队公众号才能得到flag

这里直接拿了

flag：flag{Oh!!!!!_Y0u_f1nd_my_secret}

179.[DASCTF X CBCTF 2023｜无畏者先行]签到

点击就送

flag：DASCTF{welcome_to_cbctf_2023}

（666又是搞特殊的题目）

是一个signin.txt

1	BCEHACEIBDEIBDEHBDEHADEIACEGACFIBDFHACEGBCEHBCFIBDEGBDEGADFGBDEHBDEGBDFHBCEGACFIBCFGADEIADEIADFH

ToyCipher 密码

对照表： 301.pdf

脚本：

cipherdic = {'M':'ACEG','R':'ADEG','K':'BCEG','S':'BDEG','A':'ACEH','B':'ADEH','L':'BCEH','U':'BDEH','D':'ACEI','C':'ADEI','N':'BCEI','V':'BDEI','H':'ACFG','F':'ADFG','O':'BCFG','W':'BDFG','T':'ACFH','G':'ADFH','P':'BCFH','X':'BDFH','E':'ACFI','I':'ADFI','Q':'BCFI','Y':'BDFI'}
ciphertext = ''
with open('signin.txt','r') as f:
    f = f.read()
    for i in range(0,len(f),4):
        block = f[i:i+4]
        for j in cipherdic:
            if block == cipherdic[j]:
                ciphertext += j
                #print('{}: {}'.format(block,j))
print(ciphertext)

得到

1	LDVUUCMEXMLQSSFUSXKEOCCG

提示我们需要将第二张表倒序排列，再对比一次

脚本2：

ciphertext = 'LDVUUCMEXMLQSSFUSXKEOCCG'

original_list = ['M','R','K','S','A','B','L','U','D','C','N','V','H','F','O','W','T','G','P','X','E','I','Q','Y']
reversed_list = original_list[::-1]

flag = ''
for char in ciphertext:
    for olist in original_list:
        if char == olist:
            oindex = original_list.index(olist)
            flag += reversed_list[oindex]

flag = flag.replace('GWHT','GWHT{')
flag = flag.replace('COOL','COOL}')
print(flag)

就得到了GWHT{TOYSAYGREENTEAISCOOL}

flag：flag{TOYSAYGREENTEAISCOOL}

181.[HDCTF2019]信号分析

PT2242信号：前面4bit表示同步码，中间的20bit表示地址码，后面的4bit表示功能码，最后一位是停止码

这个是PT2242信号，我们aud打开把长的当成1，短的当成0，再细看会发现所有段的信号都是一样的，所以我们只要分析一个就行了

得到0101010101010101000000110

这次只有25位，划分一下就是0101010101010101 00000011 0
并且这里是两位当做一位，
然后 01 代表 F，00 代表 0,11 代表 1，最后的0是结束符

flag：flag{FFFFFFFF0001}

182.[SUCTF2018]dead_z3r0

这个文件010打开看到前面部分是一段类似base64的东西，后面则是一段pyc文件

把从33 0D 0D 0A开始保存一个pyc文件

再使用在线网站反编译pyc得到

#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
# Version: Python 3.6


def encryt(key, plain):
    cipher = ''
    for i in range(len(plain)):
        cipher += chr(ord(key[i % len(key)]) ^ ord(plain[i]))
    
    return cipher


def getPlainText():
    plain = ''
    with open('plain.txt') as f:
        while None:
            line = f.readline()
            if line:
                plain += line
                continue
            break
    return plain


def main():
    key = 'LordCasser'
    plain = getPlainText()
    cipher = encryt(key, plain)
    with open('cipher.txt', 'w') as f:
        f.write(cipher.encode('base_64'))

if __name__ == '__main__':
    main()

尝试剑龙隐写，注意这里python版本是3.6（要切换）

就出了

flag：flag{Z3r0_fin411y_d34d}

183.[羊城杯 2020]TCP_IP

这个是IP数据报隐写

wireshark打开发现里面是一段对话，我们再看这个

他将隐写的内容藏进了Identification字段里面去

tshark提取出来

1	tshark -r .\attachment.pcap -T fields -e ip.id > data.txt

提取在了data.txt里面

随波逐流转ascii码

1	@iH<,{;oUp/im"QPl`yRie}NK;.D!Xu)b:J[Rj+6KKM7P@iH<,{*;oUp/im"QPl`yR

这是base91

解码脚本：

import base64
import re
import base91

def baseDec(text,type):
    if type == 1:
        return base64.b16decode(text)
    elif type == 2:
        return base64.b32decode(text)
    elif type == 3:
        return base64.b64decode(text)
    elif type == 4:
        return base64.b85decode(text)
    elif type == 5:
        return base91.decode(text.decode())
    else:
        pass

def detect(text):
    try:
        if re.match("^[0-9A-F=]+$",text.decode()) is not None:
            return 1
    except:
        pass
    
    try:
        if re.match("^[A-Z2-7=]+$",text.decode()) is not None:
            return 2
    except:
        pass

    try:
        if re.match("^[A-Za-z0-9+/=]+$",text.decode()) is not None:
            return 3
    except:
        pass

    try:
        if re.match("^[A-Za-z0-9$%()*+,-./:;?@[\]^_`{|}~]+$",text.decode()) is not None:
            return 4
    except:
        pass

    try:
        if re.match("^[^-\']+$",text.decode()) is not None:
            return 5
    except:
        pass
    
    return 5

def autoDec(text):
    floor = 0
    while True:
        try:
            code = detect(text)
            text = baseDec(text,code)
            floor += 1
            print("第{0}层：\n".format(floor),text)
            if not text:break
        except:
            break

if __name__ == "__main__":
    # with open("Autopy/crypto/doc/form",'rb') as f:
    #     content = f.read()
    content = "@iH<,{*;oUp/im\"QPl`yR*ie}NK;.D!Xu)b:J[Rj+6KKM7P@iH<,{*;oUp/im\"QPl`yR".encode()
    autoDec(content)

flag：flag{wMt84iS06mCbbfuOfuVXCZ8MSsAFN1GA}

184.[DASCTF 2023六月挑战赛｜二进制专项]签到

点击就送

flag：flag{Welcome_to_DASCTF5}

185.[watevrCTF 2019]Unspaellablle

词频分析无结果，找到原文来对比一下有什么删改的字

Children Of The Gods Transcript at IMSDb.

1	vimdiff 1.txt 2.txt

看到变红的字就是删减的字样

最后得到watevr{icantspeel_tiny.cc/2qtdez}

flag：flag{icantspeel_tiny.cc/2qtdez}

186.[BSidesSF2019]thekey

usb流量，分析一下

usbkeybroaddatahacker一下

看到了ctf{MY_FAVOURITE_EDITOR_IS_VIM}

flag：flag{MY_FAVOURITE_EDITOR_IS_VIM}

187.[INSHack2019]Passthru

给了sslkey.log文件，先解密一下

过滤get

1	http.request.method==GET

看到有很多kcahsni，比赛的名字叫inshark

查找

可以手动导一下也可以tshark

1	tshark -r capture.pcap -o 'ssl.keylog_file:sslkey.log' -Y 'http contains "GET /searchbyimage"' -T fields -e http.request.uri.query.parameter > outdata.txt

image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D82290383-7480-487c-b78b-77ac769c56cd%26kcahsni%3D9ef773fe97f56554a3b4,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D8bd542b5-2056-489e-bc1c-4f028ef27894%26kcahsni%3D26cd07e1f71df3dcee9f,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3De76528cd-17d3-490a-be20-2d817ccee04e%26kcahsni%3D1eaf89725ab93968fc52,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D491c01dd-f1a3-43c3-b3c8-30c4ab73ff4b%26kcahsni%3Df03c0a7d653539616433,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Deeed4c5d-8a5f-4b8c-a12d-a2ef007e09e2%26kcahsni%3D66333861303164636130,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Db69d43cd-ac86-4b20-acc6-6a441d94ae3e%26kcahsni%3D30663937353965366432,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3De56bc952-42c2-4631-96ee-e2e7cac51406%26kcahsni%3D30353331373634326335,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Dece42ab1-a9d1-44df-a0b5-6b7e83aa9cd0%26kcahsni%3D34323166636461643033,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D71ad1cf6-a31a-4694-812b-9ea5db6e3cad%26kcahsni%3D34656265373037376332,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D1b3c7025-b1a8-477f-9d16-89c254af258a%26kcahsni%3D62646464343732627b41,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D64ac599c-e5ac-43bc-a2e0-0447257cd5bc%26kcahsni%3D534e490b3295c3d06c24,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Dd8af7f01-5b92-4ad3-8c80-c6af467eac30%26kcahsni%3Df2a8c7e8936667dbf7fe,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D01b77323-6be9-4abd-b427-9f09d992a4df%26kcahsni%3Dce28456a0fd24ac21ec6,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D3f3e4f2f-5d92-4d3a-8ce8-f11943b42df3%26kcahsni%3Da12e3efe4b,encoded_image=,image_content=,filename=,hl=fr

主要是需要kcahsni的值

转化一下，最后reverse一下，脚本：

#Written by: mochu7
import binascii
from urllib.parse import unquote

flag=b''
with open('./outdata.txt') as f:
    for line in f.readlines():
        line = unquote(line)
        hexdata = line[line.find('kcahsni=')+8:line.find(',')]
        hexstring = binascii.unhexlify(hexdata)
        flag += hexstring
    print(flag[::-1])

得到INSA{b274dddb2c7707ebe430dadcf1245c246713502d6e9579f00acd10a83f3da95e}

flag：flag{b274dddb2c7707ebe430dadcf1245c246713502d6e9579f00acd10a83f3da95e}

188.[羊城杯 2020]逃离东南亚

第一个压缩包有张图片，随波逐流修复宽高得到解压密码：wdnmd

第二个压缩包有个文本打开发现是brainfuck加密

但是这个bf加密要以++++++++[开头，这个没有需要加上

解密出来一串base64

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

cyberchef发现是elf文件

打开发现

hei~what you want??
want a flag?
sorry~there is no flag
but maybe your can find something useful!

没什么用。看那个打架.wav

发现是slighteye隐写，解密出来得到This1sThe3rdZIPpwd——第三个压缩包的密码

有很多文件，我们慢慢查找一下，发现

elf文件下的rtld.c、malloc文件夹下的malloc.c、malloc文件夹下的arena.c发现有空格和tab组成的信息

脚本提取：

def f_read(name):
    f=open(name,"r")
    flag=""
    useless=r"abcdefghijklmnopqrstuvw\xyz;,)"
    for line in f.readlines():
        line=line.replace("\n","")
        if "}" in line:
            t = line.split("}")
            if len(t[1]) != 0:
                x = 1
                for i in useless:
                    if i in t[1]:
                        x = 0
                        break
                if x:
                    for s in t[1]:
                        if s == '\t':
                            flag += "1"
                        else:
                            flag += "0"
    f.close()      
    print(flag)
    print("*****")
f_read("rtld.c")
f_read("arena.c")
f_read("malloc.c")

得到：

01010011010011110101001100100001001000000111000001101100011001010011000010111001101100101001000000110100001100101011011000111000000100000011011010110010100100000001011010011111000100000011100100111010001101100011001000010111001100011
*****
011110010110111101110101011100100010000001100110011011000110000101100111001000000110100101110011001000000110100101101110001000000110110101100001011011000110110001101111011000110010111001100011
*****
0100011101010111010000110101010001000110011110110110001101101111011001000110010101011111011100110111010001100101011001110110000101101110011011110110011101110010011000010111000001101000011110010101111100110001011100110101111101100110011101010110111001101110011110010010000101111101
*****

得到GWCTF{code_steganography_1s_funny!}

flag：flag{code_steganography_1s_funny!}

189.[NPUCTF2020]碰上彩虹，吃定彩虹！

ntfs数据流，导出一下

=wwZlZ=8W=cndwljcdcG8wdj8W8Z8dZllGjZc=8lWjnlWd8WwZ5j=l8ccWZcZGjd5ZwZ5WZ8d=Zcwjwl5Gnn=WdwcwlnWd5lGnZWlnnwdnjnw8ndnc58d5cndl=njZl=WddjwWWwZllj5c5jGwZnZ5W=cZljdwd8c=85ndGGljcl5ccwd=W=l8w=5lwWn8WnwnWlGZwdcnGGl5G=8W==cnnWZnWjZ=wWcGwZcWc8ncWW=5jnWwcZl8W=8cdwWldlnwW5ddwlnlwncWlcwGZddj5djZWc5jcWdn5jdjwnj85GWGjnjwGd=jZGj5j==jwjlw8dlwWj5Wjn5n8dwwdjZlc5lZwdWldZlnGwl85cWnjd=WcWlwj8WGdlGncnZWGGd5ZncW5d55nW5wl=Wj8jGWnWj8jwZ=ZwWZ88nWG5nn5WlWnGdWw5Zn8jdl=nGcnll8WncZjnGn=dlwn5W8wlWjlnl5ccnGWGnnnc58WnjlGnG55Zwdn5cZdjdZZ5WljG5G5wcldd=Wlc8Z=8nGj=jWd8w8Wd=w8nccc8wZdjcnGdljZnnj5ww8885=lcWW8W8j5dG8jZZwG55GjnwZ=W5Z8G5ZlGc5ZZncZ5cd8j85GW5nj=WWncn55Gj5nj5nwnW58jG8GcnjZdWcl8wj8n=cj=8l8cn5jjcjn8lldn=Gjw8=cjcdWWjGddZljdjdZnG8djnZccZldlWllw5ZZ8wj5Gn==5w8Z=j55n=ZZ5wdww8lndwd8Wlj8WGjnl=nncZ=W8ZZWZnjjlwWGZZlZc5c==d8Zl855wZn=W=w8wWjZ85cGc==5Z8ccjdw5GnZWnGjcdGGnZ5wwwWGG5d=W5ldjwGZZdZwdG5cGGnZGlGc=W5ccWZ8=cGljdGcdld=8cj8jwn=lj88ZZ5jn5lcZ=Gdw=Zl58WZZl5ccwccwG5d5w8Z5wllj5ddnn=5=w8588WwGj=l5G55dWG8cl=GcjWwlwG=lWWnZ=dZG85Gcjc5=wnw=j==Gndnddjwn5c=c5W5wwdWlG5nWZwnGw8=lcWldcwnG5Wcjj=cWlGZc8Gn58ZWjZ85ljlncZj5cc=dZWGjd=d8ncZ8www55=cw=GWZn5ZZlnWld=cWcnclWlZG5djGW=cl8=ZG8cZwwc8wl=88W5ZwZ=jwZGGlcWcWnZZ5Zj5w5ZdZclZZWnccGw==cG8W8ZWlc8wcZ555Z85ljWG5jZ=8=wllWjWjlZc5lG8cwWlnjlGlW=l5=n=lGwnjGGjGdwj85ddW5ZwZ=ddjWldj=cjljjGwndZjWWZGcdWcZW5cdldj8WZjGljlWncZ5=8jnZWjl8wjZG5Zwlcl5dd

统计字频后得到：ZW5jcnlwdG8=

解密后：encrypto

百度一下发现这是一个加密软件，需要密钥，看另一个文件。-

sublime打开lookatme看到

莫斯密码：*.- ..- - --- -.- . -.--*

解密之后是AUTOKEY

用breakautokey解密一下

得到密码：iamthepasswd

拿去解密，注意secret文件要加扩展名“crypto”才能解密，否则是加密。

跑了很久没有结果，010打开文件看看

把这个删掉之后再试就能打开了

得到一张彩虹图片

foremost分离出一个zip，需要密码。

密码就是这张图片提取颜色然后转ascii

颜色：

ffff70
ffff40
ffff73
ffff73
ffff57
ffff64

得到：

1	704073735764

转ascii——p@ssWd

解压看到

这个是ALPHUCK——一种怪异的编程语言

在线网站： alphuck在线运行,在线工具，在线编译IDE_w3cschool转化得到flag

flag：flag{1t’s_v3ry_De1iCi0us~!}

190.[NPUCTF2020]签到

~~666这是签到题吗~~

wp视频： [NPUCTF2020]签到_哔哩哔哩_bilibili

得到一堆文件，是mc的存档文件

这个必须要用mc的1.15.2打开

点开之后一闪一闪的，长亮是1，短亮是0

然后二进制转ascii，ascii包上md5就行

flag：flag{8F108D05D23041B5866F9CB2FF109661}

191.[BSidesSF2020]barcoder

条形码修复

可以把这个截图截屏截出来，然后因为每一条竖线都有，补齐就行。

小心一点

官方条形码：

flag：flag{way_too_common}

192.[NewStarCTF 公开赛赛道]最后的流量分析

导出http流量

发现有sql注入相关内容

点开一个看一下，发现在干扰的sql注入之中都包含这条内容不存在哦的内容

全部导出http流

使用everything把这些干扰的都筛掉

之后就可以看到flag了

手提一下也很快，嫌慢就脚本

其实这题应该是盲注，不介意的话也可以直接在wireshark里判断flag（根据字母顺序等判断）

flag：flag{c84bb04a-8663-4ee2-9449-349f1ee83e11}

193.[INSHack2018]Spreadshit

又是表格题。

打开表格什么都没看到，猜测是填写了空格，查找空格，用黑色单元格填充

就能看到flag了

flag：flag{3cf6463910edffb0}

194.[GKCTF 2021]0.03

ntfs扫一下这个txt，得到了一个

1
2
3

QAZ WSX EDC
RFV TGB YHN
UJM IKO LP/

三分密码

结合原本的311223313313112122312312313311

得到密文： EBCCAFDDCE

用这个密钥来vera挂载那个磁盘，得到flag

flag：flag{85ec0e23-ebbe-4fa7-9c8c-e8b743d0d85c}

195.[羊城杯 2020]image_rar

解压得到一段MP4

binwalk提取一下，看到有一个65.jpg打不开

010发现其实是rar文件，修改一下文件头

然后我们rar2john一下

1	1.rar:$rar5$16$a2dce3925af59efb2df9851dbfc24fb1$15$bb005ea8f91bf0356c8dddcfa41ac4cb$8$62293dc5e26e9e7f

然后我们hashcat爆破一下

在kali里hash值要加引号：
hashcat -m 13000 -a 3 '$rar5$16$a2dce3925af59efb2df9851dbfc24fb1$15$bb005ea8f91bf0356c8dddcfa41ac4cb$8$62293dc5e26e9e7f' GW?a?a?a?a
在windows里不需要加引号：
hashcat.exe -m 13000 -a 3 $rar5$16$a2dce3925af59efb2df9851dbfc24fb1$15$bb005ea8f91bf0356c8dddcfa41ac4cb$8$62293dc5e26e9e7f GW?a?a?a?a

得到密码：GW5!3#

解压之后有一个flag文件，发现是png

最后得到flag GWHT{R3fresh_1s_so_Cool}

flag：flag{R3fresh_1s_so_Cool}

196.[XMAN2018排位赛]ppap

追踪tcp流量看到

复制下来cyberchef解码得到一张图片

foremost得到压缩包

没密码，在流量里又发现

发现是xml文件，开头

1	<opencv_storage>

是人脸识别信息

安装库

1	pip install opencv-python

安装失败的话建议升级一下python版本

脚本

#python脚本
import os
import sys
import cv2 #cv2模块需要自行安装
# Get all of the pictures
imgs = os.listdir('jpg') #'jpg'为分离出来的图片文件夹
# Cascade we'll be using for detection
cascade = cv2.CascadeClassifier('123.xml') #'123.xml'保存的123.xml文件
# From the clues
scaling_factor = 1.02
min_neighbors = 65  # Bumped this up until one pic was left
for img_name in imgs:
    # Load the image and run the cascade
    img = cv2.imread(os.path.join('jpg', img_name)) #'jpg'为分离出来的图片文件夹
    # print img
    detect = cascade.detectMultiScale(img, scaling_factor, min_neighbors)
    if len(detect) > 0:
        print('ok')
        for (x, y, w, h) in detect:
            # X marks the spot!
            cv2.line(img, (x, y),     (x + w, y + h), (255, 0, 0), 2)
            cv2.line(img, (x, y + h), (x + w, y),     (255, 0, 0), 2)
        # Save the new image
        cv2.imwrite(os.path.join('123', img_name), img) # '123'为新建的空文件夹

'''  
函数介绍：
 
参数1：image--待检测图片，一般为灰度图像加快检测速度；
 
参数2：objects--被检测物体的矩形框向量组；
参数3：scaleFactor--表示在前后两次相继的扫描中，搜索窗口的比例系数。
        默认为1.1即每次搜索窗口依次扩大10%;
参数4：minNeighbors--表示构成检测目标的相邻矩形的最小个数(默认为3个)。
        如果组成检测目标的小矩形的个数和小于 min_neighbors - 1 都会被排除。
        如果min_neighbors 为 0, 则函数不做任何操作就返回所有的被检候选矩形框，
        这种设定值一般用在用户自定义对检测结果的组合程序上；
参数5：flags--要么使用默认值，要么使用CV_HAAR_DO_CANNY_PRUNING，如果设置为
        CV_HAAR_DO_CANNY_PRUNING，那么函数将会使用Canny边缘检测来排除边缘过多或过少的区域
        因此这些区域通常不会是人脸所在区域；
参数6、7：minSize和maxSize用来限制得到的目标区域的范围。
'''

记得要把前面foremost分离出来的那些图片放在同目录下的jpg文件夹下。xml改名叫123.xml

得到一张图片

是一个海盗图片，根据海盗的英文猜测压缩包密码是：skullandcrossbones

得到flag

flag：flag{b31Ng_4_P1r4tE_1s_4lR1GHT_w1Th_M3}

2.2024浙江省赛复现

得到一张out.png，用zsteg跑一下发现：

得到

1	dEFfc1dGq1pxMgMWnihrMx9mewNgdvIWMvctrc

和

1	ABCDEFGHIJKLMNabcdefghijklmnopqrstuvwxyzOPQRSTUVWXYZ0123456789+/

猜测是换表的base64，解密得到flag：DASCTF{We1C0me_2_ZJCTF2024!}

2.机密文档

得到一个加密的压缩包，发现加密方式是store，猜测为明文攻击

[!NOTE]

将一个名为flag.txt的文件打包成ZIP压缩包后，发现文件名称会出现在压缩包文件头中，且偏移固定为30

且默认情况下，flag.zip也会作为该压缩包的名称

已知的明文片段有：

“flag.txt” 8个字节，偏移30

ZIP本身文件头：50 4B 03 04 ，4字节

满足12字节的要求

其中 -C 后面跟的是原本的zip，-c 后面跟的是里面需要解密出来的zip，-x 后面是已知的明文，30 表示偏移量，7468655F7365637265745F796F755F6E657665725F657665725F6B6E6F775F6861686168616861是the_secret_you_never_ever_know_hahahaha的16进制转换，即用010打开后看到的。下一个 -x 0 是zip的偏移量，504B0304是zip的16进制表示。

可以看到解压出来的keys是

1	b8edf1ff c1f93a7e f93d08e0

得到三段密钥就可以修改压缩包密码了：

![2024-12-08 141849](./Misc-Record/2024-12-08 141849.png)

修改了密码为123

解压后得到一个docm文档，猜测是跟宏有关的，wps打开发现

这里可以使用wps里查看宏，也可以olevba看

wps 里查看如下：

olevba 查看如下：

反正最后得到如下宏代码：

Sub key()
    Dim decValues As Variant
    Dim str As String
    Dim result As String
    Dim i As Integer
    Dim xorValue As Integer
    
    decValues = Array(26, 25, 28, 0, 16, 1, 74, 75, 45, 29, 19, 49, 61, 60, 3)
    str = "outguess"
    result = ""

    For i = LBound(decValues) To UBound(decValues)
        xorValue = decValues(i) Xor Asc(Mid(str, (i Mod Len(str)) + 1, 1))
        result = result & Chr(xorValue)
    Next i

End Sub

可以发现是一个异或代码，可以手搓脚本解密，也可以cyberchef

cyberchef得到如下：

1	ulhged98BhgVHYp

由于之前提示了是outguess加密，将docm后缀改为zip后在 word / media 里拿到图片 image1.jpeg

由于outguess不认识jpeg，需要我们修改后缀名为jpg

![2024-12-08 144645](./Misc-Record/2024-12-08 144645.png)

得到flag：DASCTF{B1g_S3CR3t_F0R_Y0u}

3.EZtraffic

拿到流量分析一下就可以在SMB里发现有传输流量包，导出一下

发现有三个压缩包，但是只有其中一个是final_out，即最后的zip

这里最好不要用foremost和binwalk，因为你会发现导出的压缩包里面会少东西。

打开压缩包发现

注释

1	NTLM v2 plaintext + \d{5}

这里后来才知道需要提取 NTLMv2 哈希值并破解，可以看lunatic师傅的博客这里

而且这里 + \d{5} 提示后面再跟五位数字爆破。

这里可以用tshark导出（tshark是kali自带的）

tshark -n -r eztraffic.pcapng -Y 'ntlmssp.messagetype == 0x00000003' -T fields -e ntlmssp.auth.username -e ntlmssp.auth.domain -e ntlmssp.ntlmv2_response.ntproofstr -e ntlmssp.auth.sesskey -e smb2.sesid

得到

这里我们需要的是username::domain:ServerChallenge:NTproofstring:modifiedntlmv2response并且需要以这个形式保存到txt里

rockyou #username
MicrosoftAccount #domain
db12ced50faf52f141636e80205e8f28 #ServerChallenge
66aa2c3634e34e6e330949b82d4d2a64 #NTproofstring
而modifiedntlmv2response需要我们回到流量里找一下

先过滤

ntlmssp

可以看到很多流,其中有一个是NTLMSSP_AUTH的

在里面找NTLMv2 Response，可以看到

除了NTProofStr以外的就是我们要找的modifiedntlmv2response了（注意这里复制hex值）

最后得到

rockyou::MicrosoftAccount:4936df20962cae6d:db12ced50faf52f141636e80205e8f28:01010000000000003604281b951fdb017b4045aa008508eb0000000002001e00440042004500440036004200350041002d0035003100430032002d00340001001e00440042004500440036004200350041002d0035003100430032002d00340004004800640062006500640036006200350061002d0035003100630032002d0034003100650063002d0061006400380034002d0064006400320062003500370030006400350030003900360003004800640062006500640036006200350061002d0035003100630032002d0034003100650063002d0061006400380034002d00640064003200620035003700300064003500300039003600070008003604281b951fdb01060004000200000008003000300000000000000001000000002000008029a5d8256e5c2762f439df5c06f3bc411fb0faeb3a6fa52d9273c57b09f2d10a0010000000000000000000000000000000000009001e0063006900660073002f00310030002e00310030002e0031002e00380031000000000000000000

将以上的内容保存到hash.txt中，用hashcat爆破，命令

1
2
3

.\hashcat -m 5600 hash.txt rockyou.txt
# 5600 表示NetNTLMv2模式
# rockyou是github上找的字典，还挺大

得到密码

1	haticehatice

接下来就是5位掩码爆破了，ARP秒出

得到密码haticehatice12580，解压压缩包，看到有100张图片碎片，猜测是拼图

猜测图片应该是有顺序的，不然也太难拼了

在stegsolve的rad0里看到

QCR扫一下，看到

这里需要我们按照顺序一个个的把图片更改一下

利用脚本拼接一下（脚本抄的。）

from PIL import Image
from pyzbar.pyzbar import decode
import os

def extract_lsb(imgname):
    r = []
    img = Image.open(imgname)
    width,height = img.size
    for x in range(width):
        for y in range(height):
            pixel = img.getpixel((x,y))
            r.append(str(pixel[0] & 1))
            # print(pixel)
    bin_data = ''.join(r)
    return bin_data  
            
def bin2img(bin_data):
    imgname = "tmp.png"
    pixels = []
    img = Image.new("RGB",(50,50))
    for item in bin_data:
        if item =='0':
            pixels.append((0,0,0))
        else :
            pixels.append((255,255,255))
    img.putdata(pixels)
    # img.show()
    img = img.resize((500,500)) 
    # 这里调整一下图片的大小，便于后面pyzbar的识别
    img.save(imgname)
    return imgname
    
    
def read_qrcode(imgname):
    img = Image.open(imgname)
    decode_data = decode(img)
    # print(decode_data)
    res = decode_data[0].data.decode()
    os.remove(imgname)
    return res
        
def rename_img():
    filenames = os.listdir("./final_out")
    for filename in filenames:
        try:
            src_img = "./final_out/"+filename
            bin_data = extract_lsb(src_img)
            imgname = bin2img(bin_data)
            res = read_qrcode(imgname)
            dst_img = f"./final_out/{res}.png"
            os.rename(src_img,dst_img)
            print(f"[+] {src_img} ===> {dst_img} down!!!")
        except:
            print(f"[-] {src_img} Error!!!")

def merge_img():
    cols = 10
    rows = 10
    img_list = []
    new_img = Image.new("RGB",(500,500))
    
    for i in range(1,101):
        img = Image.open(f"./final_out/{i}.png")
        img_list.append(img)
        
    for y in range(rows):
        for x in range(cols):
            idx = y * cols + x
            img = img_list[idx]
            x_offset = x * 50
            y_offset = y * 50
            new_img.paste(img,(x_offset,y_offset))
            
    # new_img.show()
    new_img.save("flag.png")
        
if __name__ == "__main__":
    # rename_img()
    merge_img()

最后得到

4.FinalSign

文章能看到的：

1	2c243f2f3b3114345d0a0909333f06100143023b2c55020912

可以发现文章里有雪隐写，里面隐写了xor的密码:

接下来cyberchef就能出了

5.非黑即白

得到一个没有后缀的文件，010打开发现是逆序的gif

利用puzzlesolver逆序回来，得到gif，再拆分一下发现全是黑白图片：

这里应该是二进制，脚本提取一下（脚本借鉴的。。）:

import hashlib
from PIL import Image

flag = ''
hash_lst = {}
pixel_list = {}
data_list = ""
for i in range(1536):
    filename = f"{i}.png"
    tmp_img = Image.open(filename)
    tmp_pixel = tmp_img.getpixel((0,0))[0]
    # print(tmp_pixel)
    if tmp_pixel < 200:
        data_list += '0'
    else:
        data_list += '1'

print(data_list)

这个需要放在文件同目录下，得到

010100000100101100000011000001000001010000000000000000010000000000000000000000001110101101011000010110010101100110011101110010111100011110011010001010100000000000000000000000000001111000000000000000000000000000001000000000000000000000000000011001100110110001100001011001110010111001110100011110000111010011110111100011000101111101011100101100011111010111101011001110111011111100000011011000010010111010010100010101110011110000101000000001011101110000101101101111111111010011001000001111111101001010100111110011110011101001100011011000001110111001110001011101111111101100000110101011010110101110101100001001100000100010101011010111100001000001010000010010110000000100000010001111110000000000010100000000000000000100000000000000000000000011101011010110000101100101011001100111011100101111000111100110100010101000000000000000000000000000011110000000000000000000000000000010000000000000100100000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000011001100110110001100001011001110010111001110100011110000111010000001010000000000010000000000000000000000000000000000000000000000000000100000000000110000000000001011000011101010101010000000001100010110010011011011011000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010000010010110000010100000110000000000000000000000000000000000000000100000000000000010000000001011010000000000000000000000000010100000000000000000000000000000000000000000000

放在cyberchef里可以看到是一个压缩包，下载下来

gif的帧间隔里隐藏了密码

要删除最后一个0，使用 cyberchef 转 ascii 码得到：

用密码解压zip得到flag：DASCTF{H3r3_1s_C0L0rful_W0rld}

6.天命人

得到zip里面是6个文件，解压之后用010打开发现是一个zip打乱了顺序分成了6个

脚本使其重新成为一个zip：（这里需要我们手动重命名顺序）

with open("1","rb") as f:
    data1 = f.read()
with open("2","rb") as f:
    data2 = f.read()
with open("3","rb") as f:
    data3 = f.read()
with open("4","rb") as f:
    data4 = f.read()
with open("5","rb") as f:
    data5 = f.read()
with open("6","rb") as f:
    data6 = f.read()
print(len(data1))
print(len(data2))
print(len(data3))
print(len(data4))
print(len(data5))
print(len(data6))

res = []
for i in range(387797):
    try:
        res.append(data1[i])
        res.append(data2[i])
        res.append(data3[i])
        res.append(data4[i])
        res.append(data5[i])
        res.append(data6[i])
    except:
        pass
print(len(res))
with open("1.zip","wb") as f:
    f.write(bytes(res))

得到一个zip，解压出来是两个有密码的zip文件

可以发现根器里面的txt很小，只有4字节，利用crc爆破一下（注意要重命名，不能出现中文

得到：C0M3_4ND_Get_S1X_R00TS!!

解压未竟zip，发现金箍棒图片是要我们手提像素点，利用脚本

import os
import re
import cv2
import argparse
import itertools
import numpy as np


parser = argparse.ArgumentParser()
parser.add_argument('-f', type=str, default=None, required=True,
                    help='输入文件名称')
parser.add_argument('-p', type=str, default=None, required=True,
                    help='输入左上顶点和右下顶点坐标 (如:-p 220x344+3520x2150)')
parser.add_argument('-n', type=str, default=None, required=True,
                    help='输入宽度间隔和高度间隔 (如:-n 44x86)')
parser.add_argument('-size', type=str, default='1x1', required=False,
                    help='输入截取图像的大小 (如:-size 7x7)')
parser.add_argument('-resize', type=int, default=1, required=False,
                    help='输入截取图像放大倍数 (如:-resize 1)')
args  = parser.parse_args()

if __name__ == '__main__':
    if re.search(r"^\d{1,}x\d{1,}\+\d{1,}x\d{1,}$", args.p) and re.search(r"^\d{1,}x\d{1,}$", args.n) and re.search(r"^\d{1,}x\d{1,}$", args.size):
        x1, y1 = map(lambda x: int(x), args.p.split("+")[0].split("x"))
        x2, y2 = map(lambda x: int(x), args.p.split("+")[1].split("x"))
        width, height = map(lambda x: int(x), args.n.split("x"))
        width_size, height_size = map(lambda x: int(x), args.size.split("x"))

        img_path = os.path.abspath(args.f)
        file_name = img_path.split("\\")[-1]

        img = cv2.imread(img_path, cv2.IMREAD_COLOR)
        row, col = img.shape[:2]

        r, c = len(range(y1, y2 + 1, height)), len(range(x1, x2 + 1, width))
        new_img = np.zeros(shape=(r * height_size * args.resize, c * width_size * args.resize, 3))
        for y, x in itertools.product(range(r), range(c)):
            for y_size in range(height_size):
                for x_size in range(width_size):
                    # new_img[y * height_size + y_size, x * width_size + x_size] = img[y1 + y * height + y_size, x1 + x * width + x_size]
                    pt1 = ((x * width_size + x_size) * args.resize, (y * height_size + y_size) * args.resize)
                    pt2 = ((x * width_size + x_size) * args.resize + args.resize, (y * height_size + y_size) * args.resize + args.resize)
                    color = img[y1 + y * height + y_size, x1 + x * width + x_size].tolist()
                    cv2.rectangle(new_img, pt1=pt1, pt2=pt2, color=color, thickness=-1)
            
        # cv2.imshow(new_img)
        cv2.imwrite(f"_{file_name}", new_img)
        print("已保存到运行目录中...")
    else:
        print("参数-p或参数-n或参数-size, 输入错误!")

1	python get_pixels.py -f 1.png -p 5x5+1915x1075 -n 10x10

得到：

这个是veracrypt加密的磁盘文件，需要我们挂载

挂载需要密钥。密钥文件

然后点加载,就能在z盘里看到flag

3.杂题

2023 sictf 一起上号不

从这道题浅看CS流量分析

拿到一个pcapng，先foremost一下得到一个zip，解压出来一个key文件

这个key肯定就是常用的.cobaltstrike.beacon_keys文件了，保存下来

之后我们还需要拿到两样东西：一个是元数据（cookie的加密数据），一个是submit.php里的data

过滤一下http很快就能发现cookie-元数据：

元数据：

1	U8jm3+oqzYLuUiRd9F3s7xVz7fGnHQYIKF9ch6GRseWfcBSSk+aGhWP3ZUyHIkwRo1/oDCcKV7LYAp022rCm9bC7niOgMlsvgLRolMKIz+Eq5hCyQ0QVScH8jDYsJsCyVw1iaTf5a7gHixIDrSbTp/GiPQIwcTNZBXIJrll540s=

接下来就是submit.php了：

内容：

000000c093dff6b2f058ba4231e3900276566441f2bb4c76e5c8480874a4d99df083054a5ea1dd4aea5523c751af7d123ee8e9f2253a5ccdcf54427d147c556b15657ee2607e92b35732f26341bc0a26c58bf2bcf2383ad640641c364159387223360cc16ff3dc14ab1f00e6ee4fb53f5e15b767bd379451d0d7b6f4aeae9db0c3f30f3ef167b7db3e6ac241643ed2513e73f9e9148ebe7afaa122ea75e945c8ab8a816179e43180257bd8be752827dd0de26826d5611ee09391ee5545897dae1d3a9698

这里的subphp有四个，对应四个心跳包，都有可能藏flag，需要一个个尝试

经尝试，第三个是藏flag的，即上面这个

执行脚本：

import hmac
import base64
import hashlib
import hexdump
import binascii
import javaobj.v2 as javaobj
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5

file_path = ".cobaltstrike.beacon_keys"
encode_data = "U8jm3+oqzYLuUiRd9F3s7xVz7fGnHQYIKF9ch6GRseWfcBSSk+aGhWP3ZUyHIkwRo1/oDCcKV7LYAp022rCm9bC7niOgMlsvgLRolMKIz+Eq5hCyQ0QVScH8jDYsJsCyVw1iaTf5a7gHixIDrSbTp/GiPQIwcTNZBXIJrll540s="
encrypt_data = "000000c093dff6b2f058ba4231e3900276566441f2bb4c76e5c8480874a4d99df083054a5ea1dd4aea5523c751af7d123ee8e9f2253a5ccdcf54427d147c556b15657ee2607e92b35732f26341bc0a26c58bf2bcf2383ad640641c364159387223360cc16ff3dc14ab1f00e6ee4fb53f5e15b767bd379451d0d7b6f4aeae9db0c3f30f3ef167b7db3e6ac241643ed2513e73f9e9148ebe7afaa122ea75e945c8ab8a816179e43180257bd8be752827dd0de26826d5611ee09391ee5545897dae1d3a9698"

def format_key(key_data):
    key_data = bytes(map(lambda x: x & 0xFF, key_data))
    formatted_key = f"-----BEGIN PRIVATE KEY-----\n"
    formatted_key += base64.encodebytes(key_data).decode()
    formatted_key += f"-----END PRIVATE KEY-----"
    return formatted_key

def decrypt(encrypted_data, iv_bytes, signature, shared_key, hmac_key):
    if hmac.new(hmac_key, encrypted_data, digestmod="sha256").digest()[:16] != signature:
        print("message authentication failed")
        return

    cipher = AES.new(shared_key, AES.MODE_CBC, iv_bytes)
    return cipher.decrypt(encrypted_data)

with open(file_path, "rb") as fd:
    pobj = javaobj.load(fd)

PRIVATE_KEY = format_key(pobj.array.value.privateKey.encoded.data)
private_key = RSA.import_key(PRIVATE_KEY.encode())
cipher = PKCS1_v1_5.new(private_key)
ciphertext = cipher.decrypt(base64.b64decode(encode_data), 0)

if ciphertext[0:4] == b'\x00\x00\xBE\xEF':
    raw_aes_keys = ciphertext[8:24]
    raw_aes_hash256 = hashlib.sha256(raw_aes_keys).digest()
    aes_key = raw_aes_hash256[0:16]
    hmac_key = raw_aes_hash256[16:]

SHARED_KEY = binascii.unhexlify(aes_key.hex())
HMAC_KEY = binascii.unhexlify(hmac_key.hex())

encrypt_data = base64.b64encode(bytes.fromhex(encrypt_data)).decode()
encrypt_data = base64.b64decode(encrypt_data)
encrypt_data_length = int.from_bytes(encrypt_data[:4], byteorder='big', signed=False)
encrypt_data_l = encrypt_data[4:]
data1 = encrypt_data_l[:encrypt_data_length-16]
signature = encrypt_data_l[encrypt_data_length-16:encrypt_data_length]
iv_bytes = b"abcdefghijklmnop"

dec = decrypt(data1, iv_bytes, signature, SHARED_KEY, HMAC_KEY)
print("AES key: {}".format(aes_key.hex()))
print("HMAC key: {}".format(hmac_key.hex()))
print(dec[12:int.from_bytes(dec[4:8], byteorder='big', signed=False)])
print(hexdump.hexdump(dec))