ISCTF2022部分WP

write-up:

战队：张伟文

队长：张伟文

Misc:

1.Welcome To ISCTF2022

关注公众号，发送ISCTF2022就会给你发送flag。

flag为ISCTF{We1c0me_T0_ISCTF&BlueShark}

2.简单社工

找图片中的关键信息例如：繁体字，小港，高雄捷运，还有末班车的时刻表。可知这个地方在台湾省高雄市，去百度中搜索高雄市中有小港地铁的路线。

由时间图可知小港站到巨蛋站时间与图片相符，然后搜索巨蛋站在左营区，可知图片所示位置在台湾省高雄市左营区巨蛋站。将台湾省高雄市左营区巨蛋站用md5加密成32位大写ISCTF{644BB9FD9D3656A78E28E76102427224}

3.KFC疯狂星期四

将下载下来的图片放在010 Editor里面，拉到下面可以看到12.png前面的标识有pk说明这个压缩包里有密码14 00 90，90说明可能是伪加密，把9改成0或偶数，然后保存，再打开压缩包，发现加密的图片没有密码，就证实这张图片为伪加密，试着更改另一个压缩包的加密，更改后发现另一个压缩包不是伪加密，是真加密，说明另一个压缩包的密码可能藏在这张伪加密的图片中。

伪加密的png图片中大小有问题，将它放入010中改变它的大小，看到图片下方出现一串字符，试着将他输入到另一个压缩包的加密图片中。

经过多次输入后发现密码为:YouVme-50

然后将解开的图片放入010_Edito中，然后拉到下方即可看到下方的flag。

ISCTF{kFc_tHuRsday-v_mE_50}

4.磁盘管理大师

将压缩包里面的镜像文件放入WinHex中发现磁盘中隐藏着真正的flag ：一张real_ture_flag的png图片

然后用diskgeniuspro5_138805软件，恢复F磁盘中的文件，发现确实有一张real_ture_flag的png图片将他导出到桌面上用Stegsolve.jar打开，发现了是LSB的隐写。

flag为ISCTF{LSB_LSB_LSB}

5.老色批了奥:

题目描述：hint:注意大小端问题

题目附件下载下来是一张png的图片：

第一步：将图片放进010_editor里面查看一下它的16进制：

在数据底部发现了一个zip的压缩包，而且压缩包里面有个flags.txt的文档，然后首先想到的是分离png图片，用foremost分离出来了一个压缩包，解压后里面有个flag的文档，打开后是：

这里一看是一个fakeflag，是一个错误的flag，看来我们想的还是太简单了，现在把png图片放进stegsolve里面看一下图片的数据信息：

这里根据出题人给的提示，然后仔细观察发现这是一个压缩包的字节数据，但是它的每个字节都是反过来的出现了大小端问题，把高位数据写在了低位，低位数据写在了高位，现在把它Save Bin下来，将数据导入到010editor里面，再将它的16进制导出来进行高位和低位的转换：

编写脚本来将这些16进制进行高低位转换：

# 读取2.txt文件中的数据
with open('D:\桌面\misc-大端小端问题/1.txt', 'r') as file:
    data = file.read()

# 将数据进行处理
data_list = data.split()  # 按空格分割数据
swapped_data = []

# 对每个十六进制数的顺序进行颠倒
for hex_number in data_list:
    swapped_hex = hex_number[::-1]  # 颠倒顺序
    swapped_data.append(swapped_hex)  # 添加到结果列表中

# 写入3.txt文件
with open('D:\桌面\misc-大端小端问题/3.txt', 'w') as file:
    file.write(' '.join(swapped_data))

转换后：

再将这些16进制导入进010editor：

导入后发现它的数据字节就出现了很明显的压缩包文件名PK,再将它另存为.zip的形式，解压后就可以得到flag的txt文档，打开后就得到了正确的flag。ps：这里我保存为压缩包的形式解压时出现了错误，我又进行了foremost分离，在分离出的压缩包就可以正常的解压打开得到flag：

最后得到正确的flag:ISCTF{A76510E3-FEA7-68F8-2C31-0A4ECAE5197A}

6.手残党福利：

题目描述：聪明的你肯定是选择手打通关啦

解题方法：题目附件下载下来是一个小游戏，进去后发现好像要玩通过可以得到flag

退出后发现会生成一个save的保存文件：

将save1文件，放进010_editor里面，修改一下的跳关，将33修改成47跳关

再进去游戏就可以得到flag

flag：ISCTF{IWANNA_IS_EASY}

7.可爱的emoji：

题目描述：emoji可爱捏，hint1：KEY★★★★★（★为纯字母），hint2：你所寻找的就在眼前

解题方法：题目附件下载下来之后是一个真加密的压缩包，根据hint1去爆破压缩包的密码

爆出密码：KEYISAES

解开压缩包之后里面的txt有一堆emoji：

🤣🔪📂🎈🚹🛩☺🚰😇✅👣😎🍴🏹👌❓🎃👉🚫🚪😡💧📮😎🍵🐍🚫🔪🍴🐅👁🐍😁☃📮😀🎤🌏✅🚪🏹🚰💵😍🛩🚰😍🥋✖🍎✅🌏✉😂🌊🔪🔪🕹🎅🌏📮🚹😊😆

然后根据hint2说你所寻找的就在眼前，发现密码说 KEY IS AES，然后去搜索emoji-aes在线解密

https://aghorler.github.io/emoji-aes/#

Rotation这里可以多次去尝试，Key就是AES，hint2中有九个字，对应的Rotation就是9

然后就可以得到flag：

flag：ISCTF{Love1y_enn0ji}

8.小蓝鲨的秘密：

题目描述：Oursecret

解题方法：附件下载下来是一个有密码的压缩包，把它放进010_editor里面看一下是否是伪加密，发现里面的hint.txt是伪加密，图片是真加密

得到hint.txt

然后爆破压缩包来获得png图片的密码

最后得到png的M密码：114514

解压缩得到：

这里的png图片提示我们是OurSecret，我们用OurSecret来解密，根据hint的提示说密码都是一样的，这里的OurSecret解密的password也是1145114

解码出里面有个flag.txt的文档得到flag：

ISCTF{bluesharkinfo_1s||24rarht83_xyy}

9.酱紫乱：

题目描述：好像得用脚本

解题方法：附件下载下来发现里面有2000多个txt文档，每一个文档里面有一个字符，用python脚本将所有的字符读取出来：

sflag = ''
for i in range(2896):
    f = open(f'D:\桌面\challenge/{i}.txt','r').read()
    sflag += f
print(sflag)

得到：

进行base64解码得到：

发现有许多的相同的字符，说明是字频统计，用字频统计脚本跑一下，就得到flag

综合上面几种，编写一个一次性脚本：

import os
import collections
import base64

sflag = ''
for i in range(2896):
    f = open(f'challenge/{i}.txt','r').read()
    sflag += f

dflag = base64.b64decode(sflag.encode()).decode()
s = collections.Counter(dflag).most_common()
print(''.join(s[i][0] for i in range(len(s))))

得到flag：

ISCTF{so_cLut73r}

10.捕风的魔女：

题目描述：图形也可以蕴含很多信息！

解题方法：附件下载下来后发现里面是两张png的图片，flag1.png和flag.png

flag1为魔女之旅的文字表

flag2为提瓦特文字表

解码得到flag:

ISCTF{VLIXCBXZDZLSFXRXIUBWWZXDFFOXMGJL}

11.东南亚好玩吗？来南非看看吧：

题目描述：逃亡2！你能逃离南非公司的魔爪吗？

解题方法：附件下载下来后发现里面有三个压缩包日记，第一个没有加密，后面两个日记进行了加密

解压出第一个压缩包，里面有个一个密码本.txt的文档，这个密码本.txt可能是日记2爆破的字典，我们用工具来爆破一下

得到了日记2压缩包的密码，解压出来，里面有个.doc的word文档，word隐写，在设置中设置一下

就可以得到一串字符串：

nDjq8SzyL98fT3nH2LbMXUSsDKm5XfWqjv

经过多次试验，发现是base58解码，解码得到：

passwd:DontAskjustHelp!!!

这里我们得到日记3压缩包的密码，解压得到三个文件

根据hint.txt说明有MD5加密

将雪景.png放进010_editor里面查看一下他的十六进制，在末尾发现32字节数据为非图片数据

正常的png图片数据末尾是：

而这里是：

将多的32字节的数据提取出来：

611d29c748a7931c825a247fcf3f290e

然后又联想的hint.txt，有MD5加解密，说明这段32字节的数据可能是MD5加密的结果，我们用MD5解密一下

Encrypt

根据雪景，提示我们可能是snow隐写，密钥是Encrypt，密文是flag.txt

用snow隐写解密一下：

得到flag：ISCTF{1f1bbb34-3776-a5f1-c3c4-b0c265f997e8}

CRYPT0:

1.这是什么古典玩意

part1 部分SUpXSEtaS1ROQlFYRTJZPQ== 是base64再转base32得到BlueShark

part2 部分5c 75 35 33 5c 75 36 35 5c 75 36 35 5c 75 36 44 5c 75 37 33 5c 75 35 33 5c 75 33 30 是16进制的一个转换后得到 SeemsS0

part3 部分查阅古典密码学后发现是猪圈密码根据图片找对应的字符后得到 cute

组合后的flag是ISCTF{BlueShark_SeemsS0_cute}

2.呜呜呜我的md5脏了：

题目描述：md5被打乱了捏

解题方法：附件下载下来是一个txt文档：

g0at无意间发现了被打乱的flag：I{i?8Sms??Cd_1?T51??F_1?}
但是好像缺了不少东西，flag的md5值已经通过py交易得到了：88875458bdd87af5dd2e3c750e534741

注意观察题目打乱的flag，flag的格式是ISCTF{}，所以 I{i?8Sms??Cd_1?T51??F_1?} 这里是有一层栅栏加密的

栅栏解密之后得到ISCTF{md5_is_11??1??8???}

接下来就是常规的Hash值爆破了，看到都是数字，猜测?也是数字

import hashlib

def md5(str):
    m = hashlib.md5()
    m.update(str.encode("utf-8"))
    return m.hexdigest()
for i in range(100):
    for j in range(100):
        for k in range(1000):
            flag="ISCTF{md5_is_11"+str(i)+"1"+str(j)+"8"+str(k)+"}"
            #print flag
            if str(md5(flag))=="88875458bdd87af5dd2e3c750e534741":
                print (flag)
                break

得到flag：ISCTF{md5_is_11451438324}

3.咦 这个密码 怎么怪怪的：

题目描述：简单的base

解题方法：附件下载下来是许多串类型base的编码：

JVAB6NR=
FCFOQCB=
JG6NSTP=
UPM4BGU=
GN3VKM==

这是个有点脑洞的密码题，根据题目可以想到肯定是base系列的密码，ISCTF base32加密后为JFJUGVCG就可以很容易看出这是一个栅栏密码，栅栏解密：

JFJUGVCGPNAF6M3BON4V6QSBKNCTGMRBPU======

然后base32解码得到flag：

ISCTF{@_3asy_BASE32!}

4.babyrsa：

题目描述：你真的会rsa吗，flag格式为:blueshark{xxxxxx}

解题方法：题目附件下载下来，得到加密源码：

from Crypto.Util.number import *
from flag import flag
import gmpy2
import libnum

m = bytes_to_long(flag)
p = libnum.generate_prime(1024)
q = gmpy2.next_prime(p)
e = 0x10001
n = p * q
phi=(p-1)*(q-1)
c=pow(m,e,n)
print("phi =",phi)
print("c =",c)
# phi = 11998145197184838105291668748328177280207361667546370722759758550200386112478801305683579153942751165452647656673385449297455560085865712968985383490367475984832103238596934094135353170257339614559178443729484992289380330326343473326373076256926770972074683466001586625109364413771716300886242679064050279982192814946404692347546718488456485946902248120569680365122714051066115263800073280766317934165938044443605816890762489369759667593014079143278938847700684310154017484382180324831332527966465023501690149664921975200082428884572496102388046780321762496321487913829155767534947229165886644311869593584303424397016
# c = 5664235030100231880171042228110930207351619841860785495929861788749956436657598539033166266920085041056539484368799525891006461921744810454002229224070342640529484554920046100814190479604751667796353636578589439575896923937945959721385425716210546145718343511555866077148390467362495462929359632111674082222918151696522137240478900570056689827712787018876034334301771868147820786419006234529563416734953393480238739362002713175495890402512002469332947145115452344040709333447223824491510840788018172189866931550385951940611161143400804317944263940630025758568750312753125034413169961147691163044924934280636235493483

分解相邻素数，求出模数n

题目里是相邻的p,q，可以直接解

import gmpy2
from Crypto.Util.number import *

phi = 11998145197184838105291668748328177280207361667546370722759758550200386112478801305683579153942751165452647656673385449297455560085865712968985383490367475984832103238596934094135353170257339614559178443729484992289380330326343473326373076256926770972074683466001586625109364413771716300886242679064050279982192814946404692347546718488456485946902248120569680365122714051066115263800073280766317934165938044443605816890762489369759667593014079143278938847700684310154017484382180324831332527966465023501690149664921975200082428884572496102388046780321762496321487913829155767534947229165886644311869593584303424397016
c = 5664235030100231880171042228110930207351619841860785495929861788749956436657598539033166266920085041056539484368799525891006461921744810454002229224070342640529484554920046100814190479604751667796353636578589439575896923937945959721385425716210546145718343511555866077148390467362495462929359632111674082222918151696522137240478900570056689827712787018876034334301771868147820786419006234529563416734953393480238739362002713175495890402512002469332947145115452344040709333447223824491510840788018172189866931550385951940611161143400804317944263940630025758568750312753125034413169961147691163044924934280636235493483
e = 65537

r, _ = gmpy2.iroot(phi,2)
q = gmpy2.next_prime(r)
p = phi // (q-1) + 1
n = p*q
d = gmpy2.invert(e,phi)
m = pow(c,d,n)
print(long_to_bytes(m))

得到flag：blueshark{ISctf_i4_interest1ng}

5.ezcry:

题目描述：ezcry

解题方法：附件下载下来之后，得到加密的源码：

from Crypto.Util.number import *
import gmpy2
from flag import flag
m = bytes_to_long(flag)
p = getPrime(1024)
q = getPrime(1024)
s = getPrime(128)
k = getPrime(128)
n = p * q
e = 65537
seek1 = p*s
seek2 = q*k
seek3 = s*k
c = pow(m,e,n)
print(n)
print(seek1)
print(seek2)
print(seek3)
print(c)
"""
17034526359906374675222899048129793386473729727961851733668266173715506273934226618903915327347680201386438684211280871430960401386916021458749533875225149368757915582850037170031336862864220965224712317292408675261654733853726119671544885158743864358155418727967683788352892259519172776767011253307992508658787036093010953540438865556151687132667690293590304094069132122821611257522409132491206241878258953750975043892338280574703622715614385904469190033441247428911800257097240824225432194243602777112774675510936575635571170740329720227162079500469956310746873132644419840611848333802207608652869080821316814006039
31064534580137722018723185060822560614595271317101024671103834301982025703308358280617670492170754990183711198694392500995348706299728134379707212369534471489902209545060592051514886997951859233729914969365008090709174580598044945031296428531946547802954873288796478626936584991410702713951383782424003825610226728036611739090258953115031673157531
24213197274140919663950771475506320265583015671558310318006684746019240494812396672068641326932339831508586851960432536051863105773343184877340119017546817780287117748145293115469964769795237573829418533841547969451268532899237529671580701722254679851009751345719473395857872899046537572034595080443184983155696803469587776652323407147950333716539
44155715757886274586781970607943060213741487009882893164192666734219021562031
6636871845889289821451339461667353441602430792099749101933216934629214305159040913567522609116395485018234259025910227221402350884391969711051377864656945164699379734982178962637190192088596776288873871651609167259167456816094141938735498585327839045360319836147041837569528592447701501104067430848582239927052031661696213986982946173792468753773505681630323945625892041031455025095934790620541499679023777086690062211807019645557781380979957862910047981754126193036968611612056475750787560328372643151874535031184052794483578557248028165948247504989100884012688908781349748818365779371062209169311607720595792421590
"""

编写解密脚本：

from Crypto.Util.number import *
import gmpy2
seek1 = 31064534580137722018723185060822560614595271317101024671103834301982025703308358280617670492170754990183711198694392500995348706299728134379707212369534471489902209545060592051514886997951859233729914969365008090709174580598044945031296428531946547802954873288796478626936584991410702713951383782424003825610226728036611739090258953115031673157531
seek2 = 24213197274140919663950771475506320265583015671558310318006684746019240494812396672068641326932339831508586851960432536051863105773343184877340119017546817780287117748145293115469964769795237573829418533841547969451268532899237529671580701722254679851009751345719473395857872899046537572034595080443184983155696803469587776652323407147950333716539
seek3 = 44155715757886274586781970607943060213741487009882893164192666734219021562031
n = 17034526359906374675222899048129793386473729727961851733668266173715506273934226618903915327347680201386438684211280871430960401386916021458749533875225149368757915582850037170031336862864220965224712317292408675261654733853726119671544885158743864358155418727967683788352892259519172776767011253307992508658787036093010953540438865556151687132667690293590304094069132122821611257522409132491206241878258953750975043892338280574703622715614385904469190033441247428911800257097240824225432194243602777112774675510936575635571170740329720227162079500469956310746873132644419840611848333802207608652869080821316814006039
e = 65537
c = 6636871845889289821451339461667353441602430792099749101933216934629214305159040913567522609116395485018234259025910227221402350884391969711051377864656945164699379734982178962637190192088596776288873871651609167259167456816094141938735498585327839045360319836147041837569528592447701501104067430848582239927052031661696213986982946173792468753773505681630323945625892041031455025095934790620541499679023777086690062211807019645557781380979957862910047981754126193036968611612056475750787560328372643151874535031184052794483578557248028165948247504989100884012688908781349748818365779371062209169311607720595792421590
s = gmpy2.gcd(seek1,seek3)
k = gmpy2.gcd(seek2,seek3)
p = seek1 // s
q = n // p
d = gmpy2.invert(e,(p-1)*(q-1))
m = pow(c,d,n)
print(long_to_bytes(m))

得到flag：ISCTF{iiii|||yesyes||7777}

6.蓝鲨密码：

题目描述：你见过蓝鲨密码吗？

解题方法：附件下载下来是一个txt文档

第一步：将所有的蓝鲨替换成Ook，进行Ook解密，得到一串字符：

67414E6C686C6438676C396267414E6C686C6438676C396238356438676C39626B5178316B414A326A356C35383439636C6B6B776B5178316B4149776B5178316B414A6A69343569695139636C6B6C326A356C356B5178316B414A326A356C35383439636C6B6C6A6934356969526438676C39626B5178316B4149776B5178316B414A326A356C3567414E6C686B39636C6B6C326A356C3538356438676C39626B5178316B414A326A356C3538356438676C396238356438676C39626B5178316B414A6A69343569694F316A6934356969526438676C39626B5178316B414A6A69343569694F316A69343569695139636C6B6B776B5178316B414A326A356C356B5178316B41497767414E6C686C6438676C396267414E6C6869316A6934356969526438676C3962383439636C6B6C6A69343569694F316A6934356969526438676C396267414E6C686C6438676C3962383439636C6B6C326A356C3567414E6C686B39636C6B6C326A356C35

一看只有0-9和A-F的编码就是hex解码：

第二步：进行hex解码：

gANlhld8gl9bgANlhld8gl9b85d8gl9bkQx1kAJ2j5l5849clkkwkQx1kAIwkQx1kAJji45iiQ9clkl2j5l5kQx1kAJ2j5l5849clklji45iiRd8gl9bkQx1kAIwkQx1kAJ2j5l5gANlhk9clkl2j5l585d8gl9bkQx1kAJ2j5l585d8gl9b85d8gl9bkQx1kAJji45iiO1ji45iiRd8gl9bkQx1kAJji45iiO1ji45iiQ9clkkwkQx1kAJ2j5l5kQx1kAIwgANlhld8gl9bgANlhi1ji45iiRd8gl9b849clklji45iiO1ji45iiRd8gl9bgANlhld8gl9b849clkl2j5l5gANlhk9clkl2j5l5

第三步：这里一眼看不出是什么编码，但是可以通过赛博厨子的Majic，可知是base64换表：

BLUESHARKBLUESHARK SHARKSHARKBLUE BLUE SHARK SHARKSHARKBLUEBLUESHARKBLUE BLUESHARKSHARKSHARK SHARKBLUEBLUEBLUEBLUE SHARKSHARKBLUE SHARK SHARKSHARKSHARK SHARKSHARKSHARKSHARK SHARKBLUE SHARKBLUESHARK BLUESHARKBLUE SHARKSHARK BLUESHARK SHARKSHARKBLUESHARK BLUEBLUEBLUEBLUEBLUE

第四步：这里仔细一看像莫斯密码，通过尝试，这里是BLUE 替换成 - 然后SHARK 替换成 .

-.-. ..- - . ..--.- -... .---- ..- . ... .... .- .-. -.- .. -. ..-. -----

最后解码得到flag：

ISCTF{CUTE_B1UESHARKINF0}

7.ezRSA:

题目描述：小蓝鲨被这道题目难住了，你能帮帮他吗？

解题思路：附件下载下来，得到加密的源码：

from Crypto.Util.number import *
from flag import flag
import gmpy2
import libnum
import random

flag="ISCTF{************}"
m=libnum.s2n(flag)

while 1:
    e = random.randint(100,1000)
    p=libnum.generate_prime(1024)
    q=libnum.generate_prime(1024)
    phi_n=(p-1)*(q-1)
    t=gmpy2.gcd(e,phi_n)
    if  gmpy2.invert(e // t, phi_n) and t !=1:
        break
n=p*q
c=pow(m,e,n)
print("p=",p)
print("q=",q)
print("e=",e)
print("c=",c)
'''
146061540583135242741006647792481468215928177245453689591382075771990192360040412020479342624228118794110240955451899373848827328177557126556072570082923983968091404980923313006963667391261364191537502509633623502033578910844508808321175673461956149400289968262858691371016246515264343715246136003074155184273
106988826778655284666865642844938578070029566283623778317110345394696520999319699165122638213405544697509248818119744714371964212582672270467711234178627339558783803718844973937701655329775612593193896887658613019039808270266901149871250769922857432588126510259997039777751047281603319139760808677732919216899
740
6282526058961246581872664236584053247822096703448673698014149841099601111078858783085447440545491467659016466697346055841162217815656467685468263870813754625318960798390457353869689600971254126026498299128586642169553158659216998193596000256435504143502966206895545701691216757482393700125791878031903647831939512035110314068235625347074791191183719857770670134500097347113475463330210378392860796906074883251200522628116993249459465350593837432195675595929482809838619649519612607292091411530134831844063986714485104831320923176335931609571205307034732956741442770883207107022828296237748601658720079333177460160664
'''

当e约去公约数后与phi互素

import gmpy2
from Crypto.Util.number import *


# 当e约去公约数后与phi互素
def decrypt(p, q, e, c):
    n = p * q
    phi = (p - 1) * (q - 1)
    t = gmpy2.gcd(e, phi)
    d = gmpy2.invert(e // t, phi)
    m = pow(c, d, n)
    print(m)
    msg = gmpy2.iroot(m, t)
    print(msg)
    if msg[1]:
        print(long_to_bytes(msg[0]))

p=146061540583135242741006647792481468215928177245453689591382075771990192360040412020479342624228118794110240955451899373848827328177557126556072570082923983968091404980923313006963667391261364191537502509633623502033578910844508808321175673461956149400289968262858691371016246515264343715246136003074155184273
q=106988826778655284666865642844938578070029566283623778317110345394696520999319699165122638213405544697509248818119744714371964212582672270467711234178627339558783803718844973937701655329775612593193896887658613019039808270266901149871250769922857432588126510259997039777751047281603319139760808677732919216899
e=740
c=6282526058961246581872664236584053247822096703448673698014149841099601111078858783085447440545491467659016466697346055841162217815656467685468263870813754625318960798390457353869689600971254126026498299128586642169553158659216998193596000256435504143502966206895545701691216757482393700125791878031903647831939512035110314068235625347074791191183719857770670134500097347113475463330210378392860796906074883251200522628116993249459465350593837432195675595929482809838619649519612607292091411530134831844063986714485104831320923176335931609571205307034732956741442770883207107022828296237748601658720079333177460160664

decrypt(p, q, e, c)

得到flag：ISCTF{1dedc976-d253-4053-b2f5-557282f41fc5}

REVERSE:

1.SigninReverse:

打开靶机将文件下载到桌面用IDA打开，F5查看伪代码就发现了flag

flag为ISCTF{4659a3f3-539d-49a3-8760-97a85c38f46b}

2.ezbase：

题目描述：一个简单的 base 加密

解题方法：将题目附件下载下来之后，发现是一个exe文件，把它放进exeinfope.exe，来查看一下它的属性

这里我们发现他是一个64位的无壳的exe文件，然后我们把它放进IDA里面分析一下它的反汇编：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char Str2[7]; // [rsp+20h] [rbp-60h] BYREF
  char v5[45]; // [rsp+27h] [rbp-59h] BYREF
  char v6[8]; // [rsp+54h] [rbp-2Ch] BYREF
  char v7[986]; // [rsp+66h] [rbp-1Ah] BYREF
  char Str1[256]; // [rsp+440h] [rbp+3C0h] BYREF
  char v9[256]; // [rsp+540h] [rbp+4C0h] BYREF
  void *v10; // [rsp+640h] [rbp+5C0h]
  int j; // [rsp+648h] [rbp+5C8h]
  int i; // [rsp+64Ch] [rbp+5CCh]

  sub_4018D0(argc, argv, envp);
  memset(v9, 0, sizeof(v9));
  scanf("%s", v9);
  memset(Str1, 0, sizeof(Str1));
  v10 = VirtualAlloc(0i64, 0x400ui64, 0x1000u, 0x40u);
  memcpy(&v7[10], &unk_403020, 0x3C3ui64);
  strcpy(v7, "bbbbase64");  //进行赋值
  for ( i = 0; i <= 962; ++i )
    v7[i + 10] ^= v7[i % 9];
  memcpy(v10, &v7[10], 0x3C3ui64);
  ((void (__fastcall *)(char *, char *))v10)(v9, Str1);
  Str2[0] = 56;
  Str2[1] = 15;
  Str2[2] = 26;
  Str2[3] = 10;
  Str2[4] = 59;
  Str2[5] = 64;
  Str2[6] = 22;
  strcpy(v5, "Lz* V");
  v5[6] = 27;
  v5[7] = 31;
  v5[8] = 51;
  v5[9] = 85;
  v5[10] = 5;
  v5[11] = 56;
  v5[12] = 16;
  v5[13] = 48;
  v5[14] = 36;
  v5[15] = 5;
  v5[16] = 32;
  v5[17] = 49;
  v5[18] = 88;
  v5[19] = 97;
  v5[20] = 83;
  v5[21] = 53;
  v5[22] = 36;
  v5[23] = 48;
  v5[24] = 37;
  v5[25] = 36;
  v5[26] = 35;
  v5[27] = 82;
  v5[28] = 5;
  v5[29] = 54;
  v5[30] = 42;
  v5[31] = 39;
  v5[32] = 24;
  v5[33] = 48;
  v5[34] = 31;
  v5[35] = 35;
  v5[36] = 112;
  v5[37] = 86;
  v5[38] = 54;
  v5[39] = 36;
  v5[40] = 16;
  v5[41] = 6;
  v5[42] = 82;
  v5[43] = 3;
  v5[44] = 19;
  strcpy(v6, "Pe__");
  for ( j = 0; j <= 55; ++j )
    Str2[j] ^= v7[j % 9];
  if ( !strcmp(Str1, Str2) )  //可以在这里设置断点,然后查看固定值Str2的值
    puts("you win!");
  return 0;
}

这里我们通过分析它的反汇编代码知道，它将我们的输入进行base64后成Str1，后再与固定值Str2进行比较，所以我们的解题思路就是，在strcmp设置断点，进行动态调试来获取Str2的值

上面的Debugger选择 Local Windows debugger ,设置好断点，这样运行的时候就是停在断点那里

点击运行：

这里的弹窗是警告我们调试的可能是有损计算机的病毒，但我们这里是做题，所以对计算机没有危害，点yes

然后就会出现这样的界面，我们要先随便输入几个字符，然后回车它才会开始运行，并且停在你设置的断点那里

然后程序停在了红色标记那里就是我们设置的断点，然后F5反汇编一下：

这里我们就双击Str2就可以得到他的值了：

这里我们shift+E,就可以把它的数据提取出来：

ZmxhZ3szNHB4bzlVc1ZrRFdSTnU1WFRDWFd1THEzQlFFbTFrd3pvfQ==

base64解码一下就可以得到它的flag：

ISCTF{34pxo9UsVkDWRNu5XTCXWuLq3BQEm1kwzo}

补充一下，官方的WP解：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

char base64table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int findIndex(int Index, char* table)
{
    if( Index == '=' )
        return 0;
    for(int i = 0; table[i]; ++i)
    {
        if( table[i] == Index )
            return i;
    }
    return -1;
    
}

void base64Decode(char* input, char* output,char* table)
{
    int len = strlen(input);
    if( table == NULL)
        table = base64table;
    for(int i = 0, j = 0; i < len; i += 4, j += 3)
    {
        int i1 = findIndex(input[i]    , table);
        int i2 = findIndex(input[i + 1], table);
        int i3 = findIndex(input[i + 2], table);
        int i4 = findIndex(input[i + 3], table);
        output[j] = (i1 << 2) | ((i2 >> 4) & 0x3);
        output[j + 1] = (i2 << 4) | (i3 >> 2);
        output[j + 2] = (i3 << 6) | i4;
    }
    
}

int main()
{
    char flag[100] = {};
    char cmp[] = {0x38, 0x0f, 0x1a, 0x0a, 0x3b, 0x40, 0x16, 0x4c, 0x7a, 0x2a, 0x20, 0x56, 0x00, 0x1b, 0x1f, 0x33, 0x55, 0x05, 0x38, 0x10, 0x30, 0x24, 0x05, 0x20, 0x31, 0x58, 0x61, 0x53, 0x35, 0x24, 0x30, 0x25, 0x24, 0x23, 0x52, 0x05, 0x36, 0x2a, 0x27, 0x18, 0x30, 0x1f, 0x23, 0x70, 0x56, 0x36, 0x24, 0x10, 0x06, 0x52, 0x03, 0x13, 0x50, 0x65, 0x5f, 0x5f, 0};
    char key[] ="bbbbase64";
    for(int i = 0; i < 56; ++i)
    {
        cmp[i] ^= key[i % 9];
    }

    
    base64Decode(cmp, flag, 0);
    
    printf("%s\n", flag);
    getchar();
}

3.坤坤的csgo邀请：

题目描述：坤坤邀请你打see♂ass♂go。

解题方法：把附件下载下来是一个exe文件

将.exe文件放进exeinfope.exe，查看一下他的属性

发现是一个32位的，有壳的exe文件，用010_editor来修复一下壳，把它放进脱壳机里面脱壳，然后放进32位的IDA里面，搜索字符串

补充一下官方题解：

方法1、使用010修复UPX壳，再拿UPX脱壳机直接脱壳。然后拿IDA直接找flag

方法2、直接使用OD调试，定位关键点，破解程序

方法3、OD手动脱壳，然后IDA直接找flag

得到flag：ISCTF{Kun.Ku..n_loves_you.s0_m.uc.h.}

4.base64:

题目描述：base64

解题方法：题目附件下载下来是一个base64的exe文件

将它放进exeinfope.exe，查看一下它的属性：

发现它是一个无壳的64位的exe文件，把它放进IDA里面，F5查看一它的反汇编代码：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rdx
  __int64 v4; // rbx
  __int64 v5; // rax
  size_t v6; // r8
  int v7; // eax
  const char *v8; // rdx
  __int128 Buf1[3]; // [rsp+20h] [rbp-178h] BYREF
  char v11[304]; // [rsp+50h] [rbp-148h] BYREF

  memset(v11, 0, 0x12Cui64);
  strcpy((char *)Buf1, "MTU5ZTMOMjIOYzAwZWFkMmQzYTAz0WQzMjA4NGV1NTA=");
  sub_140001850(std::cin, v3, v11);
  v4 = -1i64;
  v5 = -1i64;
  do
    ++v5;
  while ( v11[v5] );
  sub_1400011A0(v11, (unsigned __int16)v5, &v11[v5 + 5]); //这个函数里面将base64换表了
  v6 = -1i64;
  do
    ++v6;
  while ( *((_BYTE *)Buf1 + v6) );
  do
    ++v4;
  while ( v11[v4] );
  v7 = memcmp(Buf1, &v11[v4 + 5], v6);
  v8 = "wrong";
  if ( !v7 )
    v8 = "success";
  sub_1400015F0(std::cout, v8);
  return 0;
}

分析后这个程序是一个base64的加密过程，但是要看一下它有没有进行了换表

这里扫一眼感觉是没有换表，但仔细一看后面的小写字母中e和o换了位置

最后放进赛博厨子里面梭哈一下就可以得到flag：

flag：ISCTF{159e34224c00ead2d3a039d32084ee50}

5.开摆Re:

题目描述：罗小黑很早以前在小黄鱼买到了一款好玩的游戏，但是卖家给的激活码忘记了，卖家也已经注销了小黄鱼账户，你能帮小黑获得这个游戏的激活码吗？（请用 ISCTF{ } 包裹flag提交）

解题方法：附件下载下来是一个exe文件

还是一样的放进exeinfope.exe，看一下它的属性：

是一个64位无壳的exe文件，把它放进IDA里面，F5查看一下它的反汇编代码：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char Str1[32]; // [rsp+20h] [rbp-50h] BYREF
  char Str[20]; // [rsp+40h] [rbp-30h] BYREF
  int v6; // [rsp+54h] [rbp-1Ch]
  char *Str2; // [rsp+58h] [rbp-18h]
  const char *v8; // [rsp+60h] [rbp-10h]
  int i; // [rsp+6Ch] [rbp-4h]

  _main(argc, argv, envp);
  v8 = "isctfajzu";
  Str2 = "123456789";
  printf(&Format);
  scanf("%s", Str);    //我们的输入str
  v6 = strlen(Str);
  if ( v6 > 5 && v6 <= 10 )
  {
    for ( i = 0; i < v6; ++i )
      Str1[i] = v8[i] ^ Str[i];  //这里将我们的输入和v8进行异或后，赋给Str1
    if ( !strcmp(Str1, Str2) )  //将Str1和Str2进行比较
      printf(&byte_14001303D);
    else
      printf(&byte_140013049);
  }
  else
  {
    printf(&byte_140013025);
  }
  system("pause");
  return 0;
}

经过分析，这里的逻辑很简单，程序将我们的输入Str，先和v8进行异或，异或后赋给Str1，最后Str1和Str2进行比较

所以我们直接编写脚本来逆向出我们的输入flag

v1 = 'isctfajzu'
str2 = '123456789'

flag = ''
for i in range(len(str2)):
    flag += chr(ord(str2[i])^ord(v1[i]))
print(flag)

最后得到我们的flag：ISCTF{XAP@SW]BL}

6.请送我一个绿茶：

题目描述：给了附件

解题方法：题目文件下载下来一看图标就知道是py打包后的exe文件，所以我们要用pyinstxtractor来进行反编译，反编译后找到对应的与EXE同名的.pyc文件：

将pyinstxtractor.py与green_tea.EXE放在同一个文件夹下，打开终端在命令行输入：

python pyinstxtractor.py green_tea.exe

然后去反编译出来的文件里面找和文件名相同的.pyc文件

去在线pyc反编译网站上面，反编译一下pyc文件得到源码：

# Visit https://www.lddgo.net/string/pyc-compile-decompile for more information
# Version : Python 3.10

from ctypes import *

def MX(z, y, total, key, p, e):
    temp1 = (z.value >> 5 ^ y.value << 2) + (y.value >> 3 ^ z.value << 4)
    temp2 = (total.value ^ y.value) + (key[p & 3 ^ e.value] ^ z.value)
    return c_uint32(temp1 ^ temp2)

def encrypt(n, flag, key):
    delta = 0x9E3779B9L
    rounds = 6 + 52 // n
    total = c_uint32(0)
    z = c_uint32(flag[n - 1])
    e = c_uint32(0)
    if rounds > 0:
        total.value += delta
        e.value = total.value >> 2 & 3
        for p in range(n - 1):
            y = c_uint32(flag[p + 1])
            flag[p] = c_uint32(flag[p] + MX(z, y, total, key, p, e).value).value
            z.value = flag[p]
        y = c_uint32(flag[0])
        flag[n - 1] = c_uint32(flag[n - 1] + MX(z, y, total, key, n - 1, e).value).value
        z.value = flag[n - 1]
        rounds -= 1
        if not rounds > 0:
            return flag

if __name__ == '__main__':
    print('please input the key1:')
    key1 = int(input())
    print('please input the key2:')
    key2 = int(input())
    flag = [key1,key2]
    k = [5,2,1,0]
    n = 2
    res = encrypt(n, flag, k)
    print('Is that the answer you want? : ', hex(res[0]), hex(res[1]))
    print('Input 0 to exit')
    stop = input()
    return None

分析一下没啥特别的，就是很标准简单的XXTEA 加密，没有任何变化之处

直接解密即可：

# coding=utf-8
from ctypes import *

_DELTA = 0x9E3779B9


def MX(z, y, total, key, p, e):
    temp1 = (z.value >> 5 ^ y.value << 2) + (y.value >> 3 ^ z.value << 4)
    # temp2 = (total.value ^ y.value) + (key[p & 3^ e.value] ^ z.value)  # p^e.value&3  二者无差别
    temp2 = (total.value ^ y.value) + (key[(p ^ e.value) & 3] ^ z.value)

    return c_uint32(temp1 ^ temp2)


def encrypt(n, v, key):
    delta = 0x9e3779b9
    rounds = 6 + 52 // n

    total = c_uint32(0)
    z = c_uint32(v[n - 1])
    e = c_uint32(0)

    while rounds > 0:
        total.value += delta
        e.value = (total.value >> 2) & 3
        for p in range(n - 1):
            y = c_uint32(v[p + 1])
            v[p] = c_uint32(v[p] + MX(z, y, total, key, p, e).value).value
            z.value = v[p]
        y = c_uint32(v[0])
        v[n - 1] = c_uint32(v[n - 1] + MX(z, y, total, key, n - 1, e).value).value
        z.value = v[n - 1]
        rounds -= 1

    return v

def decrypt(n, v, key):
    delta = 0x9e3779b9
    rounds = 6 + 52 // n

    total = c_uint32(rounds * delta)
    y = c_uint32(v[0])
    e = c_uint32(0)

    while rounds > 0:
        e.value = (total.value >> 2) & 3
        for p in range(n - 1, 0, -1):
            z = c_uint32(v[p - 1])
            v[p] = c_uint32((v[p] - MX(z, y, total, key, p, e).value)).value
            y.value = v[p]
        z = c_uint32(v[n - 1])
        v[0] = c_uint32(v[0] - MX(z, y, total, key, 0, e).value).value
        y.value = v[0]
        total.value -= delta
        rounds -= 1

    return v

#  test
if __name__ == "__main__":
    key1 = 0x7e855dd5
    key2 = 0x5416bd8c
    v = [key1, key2]

    k = [5, 2, 1, 0]
    n = 2

    res = decrypt(n, v, k)

    print(res)

得到flag：ISCTF{4444444488888888}

7.5121-babyre：

题目描述：BCD

解题方法：5121编码，可以找到5121码表进行解密，或通过算法进行逆向

加密逻辑很简单,输入十进制数，取出各位值，进行验证。但是实力有限，写不出来

官方Wp：

0001 1000 1111 0111 1110 0010 1100 0011 0000 1101

得到flag：ISCTF{1594826307}

Web:

1.EASY-PHP01

启动靶机查看源代码发现有个hint，进去以后发现是一个php绕过。

阅读代码后ISCTF=114514a 时，可以把ISCTF的两个条件绕过输出flag。

flag为ISCTF{9e4f0f02-d7c8-423c-b05a-fa1ceadb1052}