CTF之MISC练习二

一、base16解密

import base64
s='666C61677B45333342374644384133423834314341393639394544444241323442363041417D'
flag=base64.b16decode(s)
print flag

二、modbus工业协议流量包分析

三、流量包http协议分析

四、图片的影写

五、图片隐写之AES双重解密

六、图片隐写之LSB的字符反转

七、坏损图片影写

八、图片隐写之翻转

九、日历影写

十、流量包隐藏文件之PDF

十一、最基础的图片影写

十二、BrainFuck语言解密

十三、压缩包爆破

十四、影写之十六进制转换

十五、影写之有规律的字符串

十六、玩游戏获取flag

十七、动态图片分解合并

import os
from PIL import Image
 
def seoaration_gif(gif_file):
    png_dir = gif_file[:-4] + '/'
    os.mkdir(png_dir)
    img = Image.open(gif_file)
    try:
        while True:
            current = img.tell()
            img.save(png_dir+str(current)+'.png')
            img.seek(current+1)
    except:
        pass
 
if __name__=='__main__':
    gif_file = 'flag.gif'
    seoaration_gif(gif_file)

# coding=utf-8
# Data: 2021/7/7  16:13
# File : hebin.py
from PIL import Image

path = "C:\\Users\\backlion\\Desktop\\flag\\flag\\"
save_path = 'C:\\Users\\backlion\\Desktop\\flag\\'

im = Image.new('RGBA', (2 * 201, 600))  # 创建新照片

imagefile = []  # 存储所有的图像的名称
width = 0
for i in range(0, 201):
    imagefile.append(Image.open(path + str(i) + '.png'))  # 遍历，将图像名称存入imagfile

for image in imagefile:
    im.paste(image, (width, 0, 2 + width, 600))  # 将图片张贴到另一张图片上
    width = width + 2
im.save(save_path + 'result.png')
im.show()

十八、图片影写之像素取反比较

#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
def flag():
    str = [65, 108, 112, 104, 97, 76, 97, 98]
    flag = ""
    for i in str:
        flag += chr(i)
    print flag
flag()

# coding=utf8

from PIL import Image
import bitstring

im = Image.open('flag.png')
width = im.size[0]
height = im.size[1]
pim = im.load() # 读取图片的像素信息
bin_result = ''
for h in range(height):
    for w in range(width):
        if pim[w,h][0] == 255: # 判断是否是红色（R,G,B）[0]表示第一通道
            bin_result += '1'
        else:
            bin_result += '0'

# print bitstring.BitArray(bin=bin_result).bytes.encode('hex')
with open('result.jpg','wb') as f:
    f.write(bitstring.BitArray(bin=bin_result).bytes)

这个很明显了看起来像栅栏加密，下面是CTFcrack工具对其直接解密得到解密：qwlr{ddneq_@dpnwzgpc%nzqqpp_*}

1.GPX（GPS Exchange Format, GPS交换格式)是一个XML格式，为应用软件设计的通用GPS数据格式。

2.它可以用来描述路点、轨迹、路程。这个格式是免费的，可以在不需要付任何许可费用的前提下使用。它的标签保存位置，海拔和时间，可以用来在不同的GPS设备和软件之间交换数据。如查看轨迹、在照片的exif数据中嵌入地理数据

放大发现每个点都有序号，一共17个点，然后每个点都对应一个国家的名称，按照顺序记录下来

发现前面7国家城市的首字母组合BITSCTF就是flag提交的格式首字母。那么组合构成flag：BITSCTF{MAPTHEHACK}，提交发现错误

再次查看文件中有一段注释是：Use appropriate brackets and underscores to separate words if you succeed（如果成功，请使用适当的括号和下划线分隔字符)

那么重新用括号和下划线分割符号组合flag.

最终flag为：

BITSCTF{MAP_THE_HACK}

import PIL.Image as Image
img = Image.open('low.bmp')
img_tmp = img.copy()
pix = img_tmp.load()
width,height = img_tmp.size
for w in range(width):
   for h in range(height):
      if pix[w,h]&1 == 0:
         pix[w,h] = 0
      else:
         pix[w,h] = 255
img_tmp.show()

通过  QR resarch二维码扫描工具读取出内容出来：

基础知识：

89 50 4E 47 0D 0A 1A 0A 是PNG头部署名域，表示这是一个PNG图片

00 00 00 0D  描述IHDR头部的大小

49 48 44 52 是Chunk Type Code, 这里Chunk Type Code=IHDR

00 00 00 CE 00 00 00 CE 08 02 00 00 00 描述了Chunk Data，它是可变长度数据，前四个字节（前8位）是宽度，后四个字节（后8位）节是高度。

F9 7D AA 93 是IHDR的CRC校验

题目writeup:下载附件，对其进行解压得到一张misc4.png图片，但是无法打开文件通过winhex打开misc4.png图片,发现PNG图片文件头开头的 前 4位（80 59） 不对。PNG (png)，文件头：89504E47　文件尾：AE 42 60 82将其修改为89 50 并保存为flag.png依然打不开文件通过tweakPNG工具查看png图片IHDR的CRC值，发现CRC值不对
把图片文件IHDR  的crc校验值 修改为  55 d5 f6 4f 后发现 还是打不开



发现图片的宽度为0，需要根据 crc校验值 算出图片的宽度（前8位为图像宽度，后八位为图像高度）
下面通过python 脚本算出图片的宽度：
import os 
import binascii 
import struct

misc = open("misc4.png","rb").read()

for i in range(1024): 
    data = misc[12:16] + struct.pack('>i',i)+ misc[20:29]
    crc32 = binascii.crc32(data) & 0xffffffff 
    if crc32 == 0x932f8a6b: 
        print (i)
得到709,十六进制转换后得到，0x2c5接下来我们在winhex中将宽度字节改为02C5
保存为falg2.png，打开图片发现包含flag内容：最终flag为：wdflag{Png_C2c_u_kn0W}


题目名称：3-11题目附件：https://adworld.xctf.org.cn/media/task/attachments/d0430db27b8c4d3694292d9ac5a55634.png题目writeup:用 Steg-solve 打开，发现是 LSB 隐写，开头 PK是 zip 的文件头将其另存为flag.zip，打开压缩文件，发现文件已损坏于是用winrar自带的修复压缩文件的功能进行修复压缩文件
将修复好的文件保存为rebuilt.flag.zip，对其进行解压，得到一个flag.txt文件，文件内容为base64将base64通过在线工具进行解密，发现是一张PNG图片将其保存为flag1.png图片，发现无法打开该文件
如何变成图片呢，尝试直接改后缀名根本不行，这时候想到能不能base64转图片呢，百度一下找到了在线网站，直接转换得到了答案
网站：https://tool.jisuapi.com/base642pic.html
最终flag:FLAG{LSB_i5_SO_EASY}


题目名称：互相伤害!!!题目描述：flag 为flag{XXX}内的XXX内容题目附件：https://adworld.xctf.org.cn/media/task/attachments/0fb3ac2f54b7497cb35e04265c478b76.zip题目writeup:下载附件，解压附件得到一个文件flag通过file命令查看flag文件属性为pcapng流量包文件
将其后缀名改为.pcapng用Wireshark打开流量包，过滤http协议，发现存在多个jpg文件请求通过导出http对象，将jpg文件全部提取出来提取出共21个jpg文件，可以看出全部为斗图素材首先分析图15，发现其中包含了二维码图：通过在线二维码扫描（这里使用QR Rearch扫描不起）可获得一串加密的字符串：https://cli.im/deqrU2FsdGVkX1+VpmdLwwhbyNU80MDlK+8t61sewce2qCVztitDMKpQ4fUl5nsAZOI7 bE9uL8lW/KLfbs33aC1XXw==根据图片文字提示“本发布会由AES独家赞助”那么上面二维码获取的字符串为AES加密的字符串。其中图片上的文字“CTF"可能和AES解密的密钥有关。可将CTF试作为解密的密码。http://www.jsons.cn/aesencrypt/得到解密后的字符串：668b13e0b0fc0944daf4c223b9831e49以668b13e0b0fc0944daf4c223b9831e49 提交flag,发现提交失败，显然不是flag.          继续通过binwalk对其他文件进行依次分析，发现其他图片文件都包含有zip文件。对其中任意一个图片文件10.jpg进行分离得到一个压缩文件解压缩文件得到一张二维码图片，并通过QR Rearch二维码扫描工具，发现扫描出来的内容几乎都是“扔下内衣真有一线生机？？？交出内裤才有活路”仔细观察，图5文字内容可以简单理解为“扔下内衣，交出内裤”，观察斗图素材发现图11符合上述描述“来呀，互相伤害”这张图也与题目名称“互相伤害”有相同有关联。
那么就继续对图11重点分析                          图 5                                  图11通过foremost命令对其进行分离，得到一个压缩文件但是解压缩提取出来的压缩文件，提示需要密码输入上面解出来的字符串，可正常解开压缩文件可获得一张画中画的二维码图片
扫描图二维码得到字符串：“扔下内衣真有一线生机？？？？交出内裤才有活路！！！！“。
发现二维码中心还有一个二维码，将小二维码截取出来，扫码得到flag内容：
得到flag:flag{97d1-0867-2dc1-8926-144c-bc8a-4d4a-3758}但是根据题目描述，flag 为flag{XXX}内的XXX内容最终flag为：97d1-0867-2dc1-8926-144c-bc8a-4d4a-3758
题目名称：签到题题目描述：SSCTF线上选举美男大赛开始了，泰迪拿着他的密码去解密了，提交花括号内内容（Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ==）题目writeup:根据描述，那么falg提交的格式为ssctf{}或者flag{}，根据flag提交格式，因此最终的字符串必然是被栅栏密码加密过的提交花括号内容：Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ==通过ctfcarckt00ls对其进行base64解密：得到base64解密字符串：ggQ@gQ1fqh0ohtjpt_sw{gfhgs#}上段密文的开头是g所以必然还要经过以此凯撒密码加密的
通过对其凯撒解密，移位14得到看起来像FLAG格式的开头的SSC得到位移14的凯撒解密为:ssC@sC1rct0atfvbf_ei{srtse#}再栅栏密码解密，每组字数8，第二栏就是ctf内容：最终ctf结果为：ssctf{ssCtf_seC10ver#@rabit}


题目名称：隐藏的信息题目描述：这是一个被混淆的文件，但是我忘记了这个文件的密码。你能够帮助我还原明文吗？题目附件：https://adworld.xctf.org.cn/media/task/attachments/2eb44acfc89d4f0f9fa221d21ab96033.zipwireup：方法一：1.下载附件，解压附件得到一个message.txt文本文件，打开文件发现内容是一串八进制的数字，需要将其转换成ascii
2.通过 python脚本将八进制数字转换成ascii
import re
import sys
s='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 '
a=re.findall('\d{3,}',s)
for i in a:
    sys.stdout.write(chr(int(i,8)))
得到ascii：V2VsbCBkb25lIQoKIEZsYWc6IElTQ0N7TjBfMG5lX2Nhbl9zdDBwX3kwdX0K,该字符串看起来像base64加密通过ctfcarckt00ls工具的base64解密功能对其解密，得到flag
方法二：使用“八进制 十进制 ASCII相互转换【支持多个字符串】”工具解—>输入内容—>八进制转换ASCII
得到asccii：V2VsbCBkb25lIQoKIEZsYWc6IElTQ0N7TjBfMG5lX2Nhbl9zdDBwX3kwdX0Kbase64解密：https://base64.us/
最终得到flag:ISCC{N0_0ne_can_st0p_y0u}

题目名称：saleae题目附件：https://adworld.xctf.org.cn/media/task/attachments/5621c80acfbc445d9eb252b2660070b5.zip题目writeup:下载附件，对其进行解压得到一个saleae.logicdata文件，该文件为逻辑分析仪数据文件。通过谷歌搜索是需要用Logic软件打开，打开文件发现有4个channel，其中channel 0和channel 2有波形。Logic 软件下载地址：https://downloads.saleae.com/logic/1.2.18/Logic+1.2.18+Win+64+Standalone.zip在analyzers新建一个SPI项目参数设置如下，其中MOSI是主输出从输入，MISO是主输入从输出：
channel 0：规律性，等宽，是 CLK
channel 1：无波形，是主输出端 MOSI
channel 2：波形宽度不一，携带数据，为主输入端 MISO
channel 3：数据传输是低电平，为CS偏选端
直接竖着查看，可获得flagflag最终为：flag{12071397-19d1-48e6-be8c-784b89a95e07}

题目名称：intoU题目描述：I'm so into you I can barely breath.And all I wanna do is to fall in deep （IntoU歌曲歌词）题目附件：https://adworld.xctf.org.cn/media/task/attachments/d7351710703a49cda273d3284e7a3df1.zip题目writeup:下载附件，对其进行解压得到一个音频文件，通过Audacity打开音频文件进行分析，首先选择频谱图，看了大半天也没发现有flag.通过谷歌搜索，发现需要调整到较小的采样率，才有可能显示音频隐写，下面将其采样率设置为8000 HZAriana Grande---->频谱图—>采样率—>8000 HZ拖动滚动条到最右边,并视图--放大，可查看到flag内容最终获得flag:RCTF{bmp_file_in_wav}


题目名称：Excaliflag题目描述：只有一个真正的黑客可以从这个地方得到flag题目附件：https://adworld.xctf.org.cn/media/task/attachments/f3f30930116f4b168e132db45907d0ee.png题目wireup:首先下载附件，解压获得一张图片，通过stegsolve图片隐写工具打开，然后切换色块，终获得flag内容：最终得到flag:3DS{Gr4b_Only_th1s_B1ts}

题目名称：Just-No-One题目附件：https://adworld.xctf.org.cn/media/task/attachments/7932f0a447b74cfc8b6820aa706e9446.exe题目writeup:下载附件，获得一个exe可执行程序，点击安装，进入下一步，需要输入密码，猜测可能需要逆向破解密码
尝试通过winhex和IDA分析无果

仔细观察，在安装软件协议的条款里面发现了一些关于和flag有关的信息：YOU MAY SUBMIT THIS TO GET TEN POINTS（你可以提交这段字符串获得标识）。
YOU MAY SUBMIT THIS TO GET TEN POINTS: ILOVEREADINGEULAS. 那么最终flag为：ILOVEREADINGEULAS


题目名称：信号不好先挂了题目附件:https://adworld.xctf.org.cn/media/task/attachments/b90a71f6e04b427dba2f8d307de79145.zip题目writeup:下载附件，对其进行解压，获得一张apple.png图片，通过stegsolev图片隐写工具的analyse---data extract功能对图片的LSB进行查看分析发现图片的LSB隐写中包含了PK，该PK为压缩数据包头。将其保存为flag.zip 对flag.zip进行解压，发现压缩文件已损坏
通过winrar的修复压缩文件功能对已损坏的flag.zip压缩文件进行修复
保存为rebuilt.flag.zip，并对其进行解压，获得一张pen.png图片再次通过stegsolve对pen.png图片进行通道查看，发现好几个通道中都有一些条纹 然后两张图片长得一样，所以很容易想到可能是藏有盲水印，于是用opencv处理盲水印得到flag。
合成盲水印图，盲水印用到的py脚本可以在github上下载,https://github.com/chishaxie/BlindWaterMark,使用时需要安装前置opencv-python库
python  bwm.py  decode  pen.png  apple.png   flag.png
打开合成的盲水印图片flag.png，可看到flag内容：最终flag为：unctf{9d0649505b702643}

题目名称：黄金六年
题目附件：
https://adworld.xctf.org.cn/media/task/attachments/b6c6823cbfc246249941630e647bf7b6.zip
题目writeup:
下载附件，对其解压得到一个mp4视频文件，通过winhex打开，发现在末尾隐藏的base64加密字符串
也可以通过strings命令查看文件中包含的字符串strings  hj6.mp4 得到base64加密字符串：UmFyIRoHAQAzkrXlCgEFBgAFAQGAgADh7ek5VQIDPLAABKEAIEvsUpGAAwAIZmxhZy50eHQwAQADDx43HyOdLMGWfCE9WEsBZprAJQoBSVlWkJNS9TP5du2kyJ275JzsNo29BnSZCgMC3h+UFV9p1QEfJkBPPR6MrYwXmsMCMz67DN/k5u1NYw9ga53a83/B/t2G9FkG/IITuR+9gIvr/LEdd1ZRAwUEAA==通过在线解密工具，解密获得看起来像rar文件https://base64.us
这里通过python脚本将base64转换成rar压缩包：
import base64
code = "UmFyIRoHAQAzkrXlCgEFBgAFAQGAgADh7ek5VQIDPLAABKEAIEvsUpGAAwAIZmxhZy50eHQwAQADDx43HyOdLMGWfCE9WEsBZprAJQoBSVlWkJNS9TP5du2kyJ275JzsNo29BnSZCgMC3h+UFV9p1QEfJkBPPR6MrYwXmsMCMz67DN/k5u1NYw9ga53a83/B/t2G9FkG/IITuR+9gIvr/LEdd1ZRAwUEAA=="
r = base64.b64decode(code)
file = open("flag.rar", "wb")
file.write(r)
file.close()
打开压缩包，发现需要输入密码，通过爆破也没解密出来，解密密码可能和视频中的图片有关。通过free video to jpg converter，将视频中的图片提取出来下载地址：https://secure-sc-dvdvideosoft.netdna-ssl.com/FreeVideoToJPGConverter_5.0.101.201_o.exe
得到316张图片，通过仔细查看，发现有4张图片里面包含了二维码下面是提取出含有二维码的4张图片，并对4张图片中的二维码单独截图出来，通过QR Rearch进行扫描，并获得4个KEY的密码字符串。






做这种题目着实应该把屏幕调亮一点，最后一张二维码找了好久死活找不到，调亮了屏幕之后就立马找到了。
将二维码扫描获得的4个KEY的字符串按照属性拼接得到解压密码key：iwantplayctf输入iwantplayctf密码对flag.zip进行解压缩，获得flag.txt打开flag.txt获得flag
最终flag为：roarctf{CTF-from-RuMen-to-RuYuan}
题目名称：打开电动车题目描述：截获了一台电动车的钥匙发射出的锁车信号，3分钟之内，我要获得它地址位的全部信息。flag内容二进制表示即可题目附件：https://adworld.xctf.org.cn/media/uploads/task/3d93f0c47ad94e31882e0a670eb6f5cf.zip题目writeup:下载附件，对其解压，得到一个音频文件，通过Audacity打开音频文件，然后通过视图---放大查看波形图。可以看到短波和长波
短波为0，长波为1，转换得到 01 字符串：
0    011101001010101001100010
根据题目信息说需要地址位的全部信息
查资料得到：信号是由同步引导码，地址位和数据位构成
固定码遥控信号的构成:

一个是PT226x的，前面4bit表示同步码，中间的8bit表示地址码，后面的4bit表示功能码，后面最后一个是停止码一个是PT224x的，前面8bit表示同步码，中间的20bit表示地址码，后面的4bit表示功能码，后面最后一个是停止码PT226X和PT224X不同之处，PT226X 中不可能出现10这种情况，这道题就是PT224X.钥匙信号(PT224X) = 同步引导码(8bit) + 地址位(20bit) + 数据位(4bit) + 停止码(1bit)仔细查看波形图得到如下：
所以去掉前面的同步码0和后面的数据位0010得到全部20bit地址位如下：
 01110100101010100110
最终flag:flag{01110100101010100110}
题目名称：hong题目附件：https://adworld.xctf.org.cn/media/task/attachments/3fce1ffa2af0438f82c38e321d3d3032.rar题目writeup:下载附件，对其解压，得到一个hong.mp3的音频文件，通过binwalk分析音频文件包含的文件，可以看到包含有jpeg图片文件binwalk  hong.mp3通过foremost命令对hong.mp3文件进行分离，得到2个图片文件foremost  hong.mp3首先查看0000161.jpg文件，发现是一张二维码图片通过QR Rearch二维码识别工具对0000161.jpg文件进行扫描识别，得到一串十六进制字符串通过在线网站https://ab126.com,对十六进制字符串进行转换为ascii，解密出来是乱码，无用。03f30d0ad41db4576300000000000000000100000040000000730d0000006400008400005a00006401005328020000006300000000030000000700000043000000734b0000006401006402006403006404006405006406006407006707007d00006408007d0100781e007c0000445d16007d02007c01007400007c0200830100377d0100712800577c010047486400005328090000004e694d0000006972000000692e0000006948000000696f000000696e0000006967000000740000000028010000007403000000636872280300000074030000007374727404000000666c6167740100000069280000000028000000007304000000612e7079520300000001000000730a00000000011b0106010d0114024e280100000052030000002800000000280000000028000000007304000000612e707974080000003c6d6f64756c653e010000007300000000最后查看另一张00000269.jpg图片，发现图片中包含有flag内容最终flag为：BCTF{cute&fat_cats_does_not_like_drinking}


题目名称：3-1
题目附件：
https://adworld.xctf.org.cn/media/task/attachments/e395d6e5b79b4cc49ee4e5c704f872ae
题目writeup:
下载附件，对其进行解压，得到一个二进制文件flag，通过file命令查看二进制文件flag，发现文件格式为rar压缩包
file  flag
将其二进制文件flag 重命名为flag.rar,并对压缩文件进行解压，得到一个文件flag1再次通过file命令查看falg1的文件格式为pcapngfile flag1将flag1重命名为flag1.pcapng，并通过wireshark打开。搜索关键字falg，发现在http协议中有flag.zip和flag.txt进行get 请求。猜测flag和这2个文件有关。通过wireshark的导出对象---http功能可导出http请求所有的文件内容。这里导出http请求的所有对象保存到flag文件夹下
导出来2个文件分别为receiver和flag.zip,并对flag.zip进行解压缩，发现需要密码，解压密码需要在流量包中分析获得。接下继续分析流量包，对flag.rar http get 请求处进行追踪流--tcp流分析追踪 TCP 流 6 时，发现一些linux操作命令和一段 python 代码。Linux 系统账户为 root,密码为 jfm,尝试用 jfm 解压失败，接下来执行 ls,cd tf/ cd wireshark/,ls 命令。
执行 cat 1 时得到 rar 文件内容，
执行 cat 2,得到 base64 编码，解码发现乱码，尝试直接用于解压，失败
执行 cat 3,得到 一段 python 代码，代码中有 AES，猜测是需要解密
其中，那个base64应该就是密文base64加密之后的字符串。该python是一个通过AES的CBC模式将字符串进行加密或解密的脚本，其中IV是密钥也是偏移量
# coding:utf-8
from Crypto import Random
from Crypto.Cipher import AES
import sys
import base64

IV = 'QWERTYUIOPASDFGH'
def decrypt(encrypted):
  aes = AES.new(IV, AES.MODE_CBC, IV)
  return aes.decrypt(encrypted)
def encrypt(message):
  length = 16
  count = len(message)
  padding = length - (count % length)
  message = message + '\0' * padding
  aes = AES.new(IV, AES.MODE_CBC, IV)
  return aes.encrypt(message)
str = 'this is a test'
example = encrypt(str)
print(decrypt(example))
对上面python 代码进行修改 ，并对其编 码 用 base64 解 码 后 解 密 （(注意要先用base64解码才能进行AES-CBC解密）：
# coding:utf-8
__author__ = 'YFP'
from Crypto import Random
from Crypto.Cipher import AES
import sys
import base64
IV = 'QWERTYUIOPASDFGH'
def decrypt(encrypted):
  aes = AES.new(IV, AES.MODE_CBC, IV)
  return aes.decrypt(encrypted)
def encrypt(message):
  length = 16
  count = len(message)
  padding = length - (count % length)
  message = message + '\0' * padding
  aes = AES.new(IV, AES.MODE_CBC, IV)
  return aes.encrypt(message)
str = 'this is a test'
example = encrypt(str)
print(decrypt(example))
#增加如下两行
a='19aaFYsQQKr+hVX6hl2smAUQ5a767TsULEUebWSajEo='
print(decrypt(base64.b64decode(a)))
执行修改后的python 脚本，得到base64的AES解密字符串为：No_One_Can_Decrypt_Me，并将该字符串作为密码对flag.zip进行解压缩成功解压出flag.txt，打开flag.txt，获得flag
最终flag为：WDCTF{Seclab_CTF_2017}




      wdflag{My_c4t_Ho}

题目名称：4-2题目描述：格式为flag{xxxxxxxx}题目附件：https://adworld.xctf.org.cn/media/task/attachments/1ddbc89c20c845928498c22cd3faf1c4.txt题目writeup:下载附件 ，得到一个.txt文件，打开文件发现下面几个标红的字母具有一定频率数通过词频分析得到flag，附在线分析网站：https://quipqiup.com得到flag:classical-cipher_is_not_security_hs根据题目描述，提交的flag格式，最终flag为：flag{classical-cipher_is_not_security_hs}


题目名称：5-1题目附件：https://adworld.xctf.org.cn/media/task/attachments/badd3e0621ff43de8cf802545bbd3ed0题目writeup:下载附件，对其进行解压，得到一个二进制文件flag,通过命令file查看文件类型，并没有发现文件类型file  flag通过winhex打开flag文件，发现字符是加了密，猜测可能xor加密这里通过xortool(https://github.com/hellman/xortool)对flag文件进行分析.xortool.py是基于python的脚本，用于完成一些xor分析，包括:1.猜想key的长度;2.猜想key的值;3.解密一些经过xoe加密的文件.下面查看flag的xor加密的密钥长度，可以看到占比最大的百分百就是密钥长度为13 xortool  flag
xortool  flag  -l 13  -c  20参数解释：其中-l就是指定密钥长度，-c表示出现频率最高的字符。字符出现的最高频率一般为20尝试出了key：GoodLuckToYou（根据经验将试出来的），通过以下python脚本对原文件进行异或解密：
import os

c = open("flag",'rb').read()
key = "GoodLuckToYou"
def xor(c,k):
    keylen = len(k)
    res = ""
    for pos,c in enumerate(c):
       res +=chr(ord(c) ^ ord(k[pos % keylen]))
    return res
print xor(c,key)
运行python脚本得到一串字符串，其中字符串中就包含有flag内容
最终 flag为：wdflag{You Are Very Smart}

连环套娃压缩包破解之音频隐写题目名称：Miscellaneous-300题目附件：https://adworld.xctf.org.cn/media/task/attachments/f932f55b83fa493ab024390071020088.zip题目writeup:下载附件对其解压，得到一个压缩文件flag.zip，对其进行解压，提示需要输入密码，猜测需要对其压缩包进行密码爆破通过ziperello对压缩包进行爆破发现爆破出来的密码是46783，密码正好是里面压缩包名称。
通过该密码对压缩包进行解压，可成功解密解压完了，又出现了一个新的压缩包，解压压缩包，又提示需要输入密码
接着，按照上面的爆破压缩包密码的方法进行爆破
结果发现密码就是压缩包内文件名。发现的规律是：解压里面又是个压缩包，解压一波，发现又是一个压缩包，后一个文件名的名字是前一个压缩包的解压密码。
让我们编写一个sh 脚本，并调用fcrackzip命令递归地破解和提取zip文件：
crack_zip.sh:

#!/usr/bin/env bash
while [ -e *.zip ]; do
  files=*.zip;
  for file in $files; do
    echo -n "Cracking ${file}… ";
    output="$(fcrackzip -u -l 1-6 -c '1' *.zip | tr -d '\n')";
    password="${output/PASSWORD FOUND\!\!\!\!: pw == /}";
    if [ -z "${password}" ]; then
      echo "Failed to find password";
      break 2;
    fi;
    echo "Found password: \`${password}\`";
    unzip -q -P "${password}" "$file";
    rm "${file}";
  done;
done;

执行sh脚本：
bash  crack_zip.sh
让它执行一段时间后，最后会得到一个12475.zip，发现纯数字密码爆破失败，这个一个复杂的密码加密的压缩包
通过fackzip的复杂密码对其进行爆破，发现爆破出来的密码为：boyzz
./fcrackzip -u -c a1 -l 1-6 12475.zip
通过unzip对12475.zip进行解压，得到一个音频文件mess.wav
unzip -q -P b0yzz 12475.zip
通过音频隐写工具Audacity打开音频文件mess.wav,并选择频谱图，就可以查看到flag的内容。


最终 falg为:
BallsRealBolls

题目名称：双色块
题目附件：
https://adworld.xctf.org.cn/media/task/attachments/45663022307c456897d30639f56da759.zip
题目writeup:
方法一：
下载附件，对其解压，得到一个out.gif的动态图片，且只存在绿色和紫色两个颜色，分布不均匀
通过binwalk命令查看图片隐藏的文件，可以看到隐藏了png图片binwalk out.gif通过foremost命令对out.gif进行分离，可到一个00001436.png图片foremost out.gif查看分离的图片,发现图片的内容为key:ctfer2333,猜测和flag有关，且分析这张图片无异常。通过GifSplitter将out.gif文件进行分帧处理
得到576张图片，所有图片中只有紫色和绿色两种颜色，应该对应的是1和0或者0和1，可转换成01二进制数据
按照紫色1，绿色0的规则按照先后顺序排列出了以下数据：
011011110011100001000100011011000111100001001011001010110100100000111000011101110111001101101001010110000110010100101111010001010101001001000110011100000100000101001101011000010100001001010000011010010100100101100011011010100011000101110011010010000111100101000111010011110100110101101101010100010100010001101011010010110010101101110101010110000111001101010110010110100110011101110010011001010011010101000100010100110101100001110111001111010011110101101000011010000110100001101000011010000110100001101000011010000110100001101000011010000110100001101000011010000110100001101000
每八个一组转换成ascii字符。那么通过在线工具二进制转asciii，http://www.txttool.com/wenben_binarystr.asp，可得到ascii为：o8DlxK+H8wsiXe/ERFpAMaBPiIcj1sHyGOMmQDkK+uXsVZgre5DSXw==hhhhhhhhhhhhhhhh 
按照紫色0，绿色1的规则排列出以下数据：
100100001100011110111011100100111000011110110100110101001011011111000111100010001000110010010110101001111001101011010000101110101010110110111001100011111011111010110010100111101011110110101111100101101011011010011100100101011100111010001100101101111000011010111000101100001011001010010010101011101011101110010100101101001101010010001010101001111000110010101001101001011001100010001101100110101100101010111011101011001010011110001000110000101100001010010111100101111001011110010111100101111001011110010111100101111001011110010111100101111001011110010111100101111001011110010111
同理，按照上面方面，得到一些乱码字符，显然不是我们想要的加密字符串。
得到的加密字符串：
o8DlxK+H8wsiXe/ERFpAMaBPiIcj1sHyGOMmQDkK+uXsVZgre5DSXw==hhhhhhhhhhhhhhhh
这应该是des加密或者base64，但是有提示key，所以应该是des加密，key是上面的图片内容ctfer2333，正常来说des结尾是=，最后一串h去掉就好了。
然后到http://tool.chacuo.net/cryptdes解密



方法二：gif轮播之后发现是?个24*24的像素点，每个像素为1010，每个点颜?为00?00或是?00? 先把gif分离成单帧，那么可以通过 python脚本对其进行分割成不同的单帧图像。
# ! /usr/bin/env python2
# -*- coding: utf-8 -*-

import os
from PIL import Image


def main(gif_file):
    png_dir = 'C:\\Users\\backlion\\Desktop\\flag\\'
    img = Image.open(gif_file)
    while True:
        current = img.tell()
        img.save(png_dir + str(current + 1) + '.png')
        img.seek(current + 1)

if __name__ == '__main__':
    gif_file = 'out.gif'
main(gif_file)然后读取每个png中的对应点的信息，并按照8bit转换为ascii
#! /usr/bin/env python2
# -*- coding: utf-8 -*-

import os
from PIL import Image


def main():
    png_dir = 'C:\\Users\\backlion\\Desktop\\flag\\'
    ret = ""
    for i in range(0, 24):
        line = ""
        for j in range(0, 24):
            file_name = "C:\\Users\\backlion\\Desktop\\flag\\" + str(i * 24 + j + 1) + ".png"
            x = j * 10 + 5
            y = i * 10 + 5
            img = Image.open(file_name)
            img = img.convert("RGB")
            img_array = img.load()
            r, g, b = p = img_array[x, y]
            if g == 255:
                line += "0"
            if r == 255 and b == 255:
                line += "1"
            if len(line) == 8:
                ret += chr(int(line, 2))
                line = ""
    print ret


if __name__ == '__main__':
    main()



最终flag为：flag{2ce3b416457d4380dc9a6149858f71db}

题目名称：Py-Py-Py题目附件：https://adworld.xctf.org.cn/media/task/attachments/58cadd8d8269455ebc94690fd777c34a.pyc题目writeup:下载附件，得到一个pyc文件，通过uncompyle6命令将其反编译成python脚本uncompyle6  flag.pyc>flag.py其中flag.py是一个rc4的加密解密python脚本：
# uncompyle6 version 3.7.4
# Python bytecode 3.6 (3379)
# Decompiled from: Python 2.7.18 (default, Feb 27 2021, 08:40:44) 
# [GCC 10.2.1 20210110]
# Warning: this version of Python has problems handling the Python 3 "byte" type in constants properly.

# Embedded file name: pystego.py
# Compiled at: 2017-08-01 00:44:47
# Size of source mod 2**32: 1961 bytes
import sys, os, hashlib, time, base64
fllag = '9474yeUMWODKruX7OFzD9oekO28+EqYCZHrUjWNm92NSU+eYXOPsRPEFrNMs7J+4qautoqOrvq28pLU='

def crypto(string, op='encode', public_key='ddd', expirytime=0):
    ckey_lenth = 4
    public_key = public_key and public_key or ''
    key = hashlib.md5(public_key).hexdigest()  ##将public_key以MD5方式加密，再转化成十六进制
    keya = hashlib.md5(key[0:16]).hexdigest()
    keyb = hashlib.md5(key[16:32]).hexdigest()
    keyc = ckey_lenth and (op == 'decode' and string[0:ckey_lenth] or hashlib.md5(str(time.time())).hexdigest()[32 - ckey_lenth:32]) or ''
    cryptkey = keya + hashlib.md5(keya + keyc).hexdigest()
    key_lenth = len(cryptkey)
    string = op == 'decode' and base64.b64decode(string[4:]) or '0000000000' + hashlib.md5(string + keyb).hexdigest()[0:16] + string
    string_lenth = len(string)
    result = ''
    box = list(range(256))
    randkey = []
    for i in xrange(255):
        randkey.append(ord(cryptkey[(i % key_lenth)]))

    for i in xrange(255):
        j = 0
        j = (j + box[i] + randkey[i]) % 256
        tmp = box[i]
        box[i] = box[j]
        box[j] = tmp

    for i in xrange(string_lenth):
        a = j = 0
        a = (a + 1) % 256
        j = (j + box[a]) % 256
        tmp = box[a]
        box[a] = box[j]
        box[j] = tmp
        result += chr(ord(string[i]) ^ box[((box[a] + box[j]) % 256)])

    if op == 'decode':
        if result[0:10] == '0000000000' or int(result[0:10]) - int(time.time()) > 0:
            if result[10:26] == hashlib.md5(result[26:] + keyb).hexdigest()[0:16]:
                return result[26:]
        return
    else:
        return keyc + base64.b64encode(result)


if __name__ == '__main__':
    while True:
        flag = raw_input('Please input your flag:')
        if fllag == crypto(fllag, 'decode'):
            print('Success')
            print crypto(fllag, 'decode')
            break
        else:
            continue
# okay decompiling flag.pyc

根据脚本分析，在原flag.py脚本基础上，直接把下面这段代码删除了，再添加一句 print crypto(fllag,'decode')就可以修改成解密脚本。if __name__ == '__main__':    while True:        flag = raw_input('Please input your flag:')        if flag == crypto(fllag, 'decode'):            print('Success')            break        else:            continue最终修改后的解密脚本为：
# uncompyle6 version 3.7.4
# Python bytecode 3.6 (3379)
# Decompiled from: Python 2.7.18 (default, Feb 27 2021, 08:40:44) 
# [GCC 10.2.1 20210110]
# Warning: this version of Python has problems handling the Python 3 "byte" type in constants properly.

# Embedded file name: pystego.py
# Compiled at: 2017-08-01 00:44:47
# Size of source mod 2**32: 1961 bytes
import sys, os, hashlib, time, base64
fllag = '9474yeUMWODKruX7OFzD9oekO28+EqYCZHrUjWNm92NSU+eYXOPsRPEFrNMs7J+4qautoqOrvq28pLU='

def crypto(string, op='encode', public_key='ddd', expirytime=0):
    ckey_lenth = 4
    public_key = public_key and public_key or ''
    key = hashlib.md5(public_key).hexdigest()
    keya = hashlib.md5(key[0:16]).hexdigest()
    keyb = hashlib.md5(key[16:32]).hexdigest()
    keyc = ckey_lenth and (op == 'decode' and string[0:ckey_lenth] or hashlib.md5(str(time.time())).hexdigest()[32 - ckey_lenth:32]) or ''
    cryptkey = keya + hashlib.md5(keya + keyc).hexdigest()
    key_lenth = len(cryptkey)
    string = op == 'decode' and base64.b64decode(string[4:]) or '0000000000' + hashlib.md5(string + keyb).hexdigest()[0:16] + string
    string_lenth = len(string)
    result = ''
    box = list(range(256))
    randkey = []
    for i in xrange(255):
        randkey.append(ord(cryptkey[(i % key_lenth)]))

    for i in xrange(255):
        j = 0
        j = (j + box[i] + randkey[i]) % 256
        tmp = box[i]
        box[i] = box[j]
        box[j] = tmp

    for i in xrange(string_lenth):
        a = j = 0
        a = (a + 1) % 256
        j = (j + box[a]) % 256
        tmp = box[a]
        box[a] = box[j]
        box[j] = tmp
        result += chr(ord(string[i]) ^ box[((box[a] + box[j]) % 256)])

    if op == 'decode':
        if result[0:10] == '0000000000' or int(result[0:10]) - int(time.time()) > 0:
            if result[10:26] == hashlib.md5(result[26:] + keyb).hexdigest()[0:16]:
                return result[26:]
        return
    else:
        return keyc + base64.b64encode(result)

print crypto(fllag,'decode')

执行脚本，得到 flag 的值：The challenge is Steganography， 直接提交不对，加flag{}提交仍然也不对。根据脚本解密得到The challenge is Steganography，是pyc的隐写，百度到在pyc中隐藏payload的工具为stegosaurus。
https://github.com/AngelKitty/stegosaurus/releases/tag/1.0通过 stegosaurus脚本查看隐藏在flag.pyc中的字符串./stegosaurus   -x flag.pyc 最终 flag:Flag{HiD3_Pal0ad_1n_Python}

题目名称：warmup题目附件：https://adworld.xctf.org.cn/media/task/attachments/b7b7e994d7fb4316b03f446295cfd03b.zip题目writeup:下载附件，对其进行解压，得到一个png图片以及一个压缩包文件对压缩包进行解压提示需要输入密码，这里猜测可能需要爆破压缩包密码或者明文攻击、打开压缩包预览，发现其中包含的图片文件和附件解压得到的图片文件名称是一致的。猜测需要用到明文攻击。这里首先对open_forum.png图片通过winrar对其压缩成文件open_forum.zip同时查看到open_forum.zip文件的CRC232值和需要密码解密的压缩包文件warmup.zip的CRC232的值一样。那么warmup.zip压缩包解压存在明文攻击。通过ARCHRP攻击对warmup.zip进行明文攻击
这里可能完全解密成功需要一晚上，实际需要不了那么多少，在10分钟左右就可以终止。终止压缩包爆破后，可确定直接保存为warmup_decrypted.zip文件。对warmup_decrypted.zip文件进行解压缩，成功解压出三张图片，其中fuli.png和fuli2.png图片显示是一样的。通过stegsolve对其fuli.png图片进行通道查看，并没有发现啥。再次通过stegsolve对其fuli2.png进行通道查看，发现出现一些根据以上判断，2张图片存在盲水印。
合成盲水印图，盲水印用到的py脚本可以在github上下载,https://github.com/chishaxie/BlindWaterMark,使用时需要安装前置opencv-python库
通过bwm.py脚本可以将2张图片合成一张图片flag.png
python  bwm.py  decode  pen.png  apple.png   flag.png
打卡flag.png图片，可以看到flag内容最终flag为：flag{bWm_Are_W0nderfu1}
题目名称：传感器1题目描述：已知ID为0x8893CA58的温度传感器的未解码报文为：3EAAAAA56A69AA55A95995A569AA95565556 此时有另一个相同型号的传感器，其未解码报文为：3EAAAAA56A69AA556A965A5999596AA95656 请解出其ID，提交格式为flag{xxx}题目writeup:基础知识：曼彻斯特编码（Manchester Encoding），也叫做相位编码（ Phase Encode，简写PE），是一个同步时钟编码技术，被物理层使用来编码一个同步位流的时钟和数据。它在以太网媒介系统中的应用属于数据通信中的两种位同步方法里的自同步法（另一种是外同步法），即接收方利用包含有同步信号的特殊编码从信号自身提取同步信号来锁定自己的时钟脉冲频率，达到同步目的。IEEE 802.4（令牌总线）和低速版的IEEE 802.3（以太网）中规定, 按照这样的说法, 01电平跳变表示1, 10的电平跳变表示0。
方法一：
先把16进制3EAAAAA56A69AA55A95995A569AA95565556都转成2进制，得到：
1111101010101010101010101001010110101001101001101010100101010110101001010110011001010110100101011010011010101010010101010101100101010101010110
又得知曼切斯特是从低到高跳变表示“1”，从高到低跳变表示“0”，即01->1,10->0。可以看到二进制除了前4位，后面都是10,01，差分曼切斯特有跳变为"0"，无跳变为"1
那么实际上转换成的二进制为（去掉前面最前面1111）：101010101010101010101001010110101001101001101010100101010110101001010110011001010110100101011010011010101010010101010101100101010101010110
因此将编码进行曼切斯特解码：
00000000001001001101100010001001001111001010010110000100000110000001
转成16进制得到：
24d8893ca584181
又得知第一个ID为0x8893CA58的温度传感器就在第一个曼切斯特解码24d8893ca584181中，是第4位到11位为：8893ca58，转换成大写为8893CA58
根据上面原理，可将3EAAAAA56A69AA556A965A5999596AA95656，转换成曼切斯特解码为24d8845abf34119，取第4位到11位，最终为：8845ABF3
那么flag为：
flag{8845ABF3}
方法二：
python脚本（这里需要将3E前缀去掉，因为转换成二进制为1111,不存在曼切斯特解码特性）
char = "AAAAA56A69AA556A965A5999596AA95656"
result = char.replace("5","0101").replace("6","0110").replace("9","1001").replace("A","1010")
num = len(result)
flag = ""
flag_final = ""
result = "0"+result
for i in range(1,num,2):
    if result[i:i+2][0] !=result[i-1]:
        flag += "0"
    if result[i:i+2][0] ==result[i-1]:
        flag += "1"
print hex(int(flag,2)).upper()[2:]
或者：
id1 = 0x8893CA58
msg1 = 0x3EAAAAA56A69AA55A95995A569AA95565556
msg2 = 0x3EAAAAA56A69AA556A965A5999596AA95656

def calc(msg):
    id=''
    s = bin(msg)[6:]
    for i in range(2, len(s), 2):
        if s[i-2:i] == s[i:i+2]:
            id += '0'
        else:
            id += '1'
    return hex(int(id, 2)).upper()

print(calc(msg1))
print(calc(msg2))
可以看到id是取结果的4到11位，ID为：8845ABF3最终flag为：flag{8845ABF3}
题目名称：halo题目描述：答案的格式为flag{XXXX}题目附件：https://adworld.xctf.org.cn/media/task/attachments/56afc3a6c8d04cde8b1354b77fe91731.zip题目writeup:下载附件，对其进行解压得到一个txt文件，文件内容看来像base64加密通过在线base64解密网站对其进行base64解密，得到特殊的字符串：igq4;441R;1ikR51ibOOp，提交flag显示不对
尝试多种后情况后，该加密字符串为base64和异或的加密，通过以下脚本对其进行解密：
import string
from base64 import *


b=b64decode("aWdxNDs1NDFSOzFpa1I1MWliT08w")
data=list(b)
for k in range(0,200):
    key=""
    for i in range(len(data)):
        key+=chr(ord(data[i])^k)
    print (key)得到的结果，发现唯一一个没有特殊字符为：jdr78672Q82jhQ62jaLL3最终flag为：flag{jdr78672Q82jhQ62jaLL3}
题目名称：picture3

题目描述：flag提交形式为flag{XXXX}题目附件：https://adworld.xctf.org.cn/media/task/attachments/7128eb78f49242d39b71e0496c3b52ab.jpg题目writeup:下载附件，得到一张图片，通过binwalk对其进行解压。得到149EC.zip  和stego.txt文件binwalk -e  flag.jpg 查看压缩包149EC. zip文件里面包含一个stego.txt文件且CRC32值为0CF2D018，同时对其解压，提示需要输入密码，该文件名和图片解压出来的stego.txt是相同的。需要解压该压缩包文件，猜测是需要用到明文攻击、、通过winrar对stego.txt文件进行压缩成stego.txt，查看CRC32值和149EC. zip压缩包中值相同这里通过ARCHPR对压缩包149EC. zip进行明文攻击，但是明文攻击并不能恢复
通过winrar的自带修复功能对149EC. zip进行修复修复后的文件保存为rebuilt.149EC.zip，对其进行解压，发现不需要输入密码，直接解压得到一个stego.txt文件打开文件发现是很多行base64加密字符串b2Q5dU==aDk5Ni==ZG8wOW==ZzYxYh==ZjU4NT==aXBjNF==Q3dTM2==d1Y5c1==dFA3WV==ZDNQUP==ejhBMT==dUowaW==OVQ2ZD==aUM5ZU==NnFFek==ZGc0T/==NGpWNE==NVZpUW==ejZDTm==a1VEN5==azNMUX==TXlhNW==bjZwWm==Q2Q0b1==猜测可能是base64隐写：依次读取每行，从中提取出隐写位。如果最后没有‘=’，说明没有隐写位，跳过。如果最后是一个‘=’，说明有两位隐写位，将倒数第二个字符转化为对应的二进制索引，然后取后两位。如果最后是两个‘=’，说明有四位隐写位，将倒数第三个字符转化为对应的二进制索引，然后取后四位。将每行提取出的隐写位依次连接起来，每8位为一组转换为ASCII字符，最后不足8位的丢弃。通过脚本跑出隐写，获得flag:
def get_base64_diff_value(s1, s2):
    base64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    res = 0
    for i in xrange(len(s1)):
        if s1[i] != s2[i]:
            return abs(base64chars.index(s1[i]) - base64chars.index(s2[i]))
    return res


def solve_stego():
    with open('stego.txt', 'rb') as f:
        file_lines = f.readlines()

    bin_str = ''
    for line in file_lines:
        steg_line = line.replace('\n', '')
        norm_line = line.replace('\n', '').decode('base64').encode('base64').replace('\n', '')
        diff = get_base64_diff_value(steg_line, norm_line)

        pads_num = steg_line.count('=')
        if diff:
            bin_str += bin(diff)[2:].zfill(pads_num * 2)

        else:
            bin_str += '0' * pads_num * 2

    res_str = ''

    for i in xrange(0, len(bin_str), 8):
        res_str += chr(int(bin_str[i:i + 8], 2))
    print res_str

solve_stego()
根据falg提交格式，最终flag为：
flag{Ba5e_64OFive}
题目名称：7-2题目描述：提交格式为wdflag{......}题目附件：https://adworld.xctf.org.cn/media/task/attachments/118956c97c7c4a3e9b1508c1f5ea44be.zip题目writeup:下载附件，对其进行解压，得到很多文件，文件的名称都是base64加密字符串同时，打开其中任意文件，发现都是一串十进制加密字符串通过脚本对解压的所有文件夹的文件名进行将base64解密
# coding=utf-8
import os
import base64

for name in os.listdir("C:\\Users\\backlion\\Desktop\\flag\\problem\\"):
    print name
    # 由于文件名不是4的倍数，需要在后面补‘=’
    missing_padding = 4 - len(name) % 4
    if missing_padding:
        name += '=' * missing_padding
    print str(base64.b64decode(name.encode()))
执行脚本得到只有文件名YWluaWRleGluZ3podWFuZw base64解密出来的字符串ainidexingzhuang是正常显示无乱码。

打开YWluaWRleGluZ3podWFuZw文件，发现一串数字，其中包括了{和}中的数字。那么很有可能这些数字解码后就是flag得到{和}中的数字为：82 42 82 52 63 21 42 22 73 21该数字使用的是手机9键加密，第一个数字代表9键键盘下的数字，第二个数字代表该数字下的第几个字母。得到9键盘加密的字符为：uhukoahbra通过凯撒解密得到一个有意义的字符ylyoselfve就是ctf的内容。根据flag提交格式，最终flag为：wdflag{ylyoselfve}
题目名称:4433题目附件：https://adworld.xctf.org.cn/media/task/attachments/3f8b0f935fa74f3c9cea382bf3687569.rar题目writeup:下载附件，对其解压得到一张图片，通过stegsolve图片隐写工具打开，查看通道，在橙色通道中出现了一张二维码图片。通过QR Reach二维码图片扫描工具识别出内容是一串摩尔斯字符。得到内容：...--.----...--..想要解码但是不知道怎么分割，于是想到题目名称 4433，表示 4 个 4 个 3 个 3 个分隔开。那么摩尔斯密码加密密文为：...-/-.--/--./..-/-..通过在线工具工具对其解密得到：VYGUDhttps://www.bejson.com/enc/morse/将VYGUD进行flag提交，发现不对由搜索引擎搜索摩斯密码可知摩斯密码常用的缩写中：VY代表VERY，GUD代表GOOD，那么flag为内容为：VERYGOOD可参考：https://zh.wikipedia.org/wiki/%E6%91%A9%E5%B0%94%E6%96%AF%E7%94%B5%E7%A0%81#%E5%B8%B8%E7%94%A8%E7%BC%A9%E5%86%99最终flag为：flag{VERYGOOD}
题目名称：Run题目描述：Run away! nc **.**.**.** XXXX题目场景：111.200.241.244:64579题目writeup:nc连上发现是一个python沙盒逃逸，一些能引发命令执行的python库全部被禁用了。最后在网上发现这么一个文章 https://blog.csdn.net/qq_35078631/article/details/78504415
通过().class.bases[0].subclasses()获取当前加载的类
发现func_globals被过滤了，我们使用__getattribute__绕过
最终payload:
w = ().__class__.__bases__[0].__subclasses__()
o =  w[59].__enter__.__func__.__getattribute__('__global' + 's__')['s'+'ys'].modules['o'+'s']
s = o.__getattribute__('sy' + 'stem')
s('/bin/sh')执行payload得到当前sh脚本运行权限
通过cat命令查看文件5c72a1d444cf3121a5d25f2db4147ebb，得到falg最终flag:flag{eee93c33d97aa55f785a7d10ba4ae3ce}
题目名称：流量分析题目描述：sql注入题目附件：https://adworld.xctf.org.cn/media/task/attachments/4d7c14206a5c4b74a0af595992bbf439.pcapng题目writeup:下载附件，得到一个pcapng流量包文件，通过wrireshark打开该文件，根据题目描述SQL注入，那么过滤HTTP协议，对其进行分析
看到很多注入语句，sql注入语句都是字符32开始的，第一波语句结束字符是102，恰好对应的ascii为f
第二波语句结束字符是108,对应的ascii为l

第三波语句结束字符是97,对应的ascii为a
第四波语句结束字符是103,对应的ascii为g
第六波语句结束字符是123,对应的ascii为{
以此类推得到flag: flag{c2bbf9cecdaf656cf524d014c5bf046c}
也可以通过python脚本获取
import re
import os

def getflag(contents):
    req_reg  = re.compile(r'0,1\),(\d+),1\)\)=(\d+)%23')
    results = req_reg.findall(contents)
    flag_map = {}
    for result in results:
        if result[0] in flag_map:
            if int(result[1]) > flag_map[result[0]]:
                flag_map[result[0]] = int(result[1])
        else:
            flag_map[result[0]] = int(result[1])
    flag = ""
    for i in range(1,39):
        flag += chr(flag_map[str(i)])
    print(flag)

if __name__ == "__main__":
    basedir = os.path.dirname(__file__)
    filename = "misc.pcapng"
    file_path = os.path.join(basedir, filename)
    print(filename)
    with open(file_path, 'rb') as f:
        getflag(f.read())
最终得到falg:flag{c2bbf9cecdaf656cf524d014c5bf046c}


题目名称：传感器2题目描述：已知ID为0x8893CA58的温度传感器未解码报文为：3EAAAAA56A69AA55A95995A569AA95565556 为伪造该类型传感器的报文ID（其他报文内容不变），请给出ID为0xDEADBEEF的传感器1的报文校验位（解码后hex），以及ID为0xBAADA555的传感器2的报文校验位（解码后hex），并组合作为flag提交。例如，若传感器1的校验位为0x123456，传感器2的校验位为0xABCDEF，则flag为flag{123456ABCDEF}。题目writeup:方法一：
先把16进制3EAAAAA56A69AA55A95995A569AA95565556都转成2进制，得到：
1111101010101010101010101001010110101001101001101010100101010110101001010110011001010110100101011010011010101010010101010101100101010101010110
又得知曼切斯特是从低到高跳变表示“1”，从高到低跳变表示“0”，即01->1,10->0。可以看到二进制除了前4位，后面都是10,01，差分曼切斯特有跳变为"0"，无跳变为"1
那么实际上转换成的二进制为（去掉前面最前面1111）：101010101010101010101001010110101001101001101010100101010110101001010110011001010110100101011010011010101010010101010101100101010101010110
因此将编码进行曼切斯特解码：
00000000001001001101100010001001001111001010010110000100000110000001
转成16进制得到：
24d8893ca584181
又得知第一个ID为0x8893CA58的温度传感器就在第一个曼切斯特解码24d8893ca584181中，是第4位到11位为：8893ca58，ID转换成大写为：8893CA58
根据上面原理，可将3EAAAAA56A69AA556A965A5999596AA95656，转换成曼切斯特解码为24d8845abf34119，取第4位到11位，ID转换成大写为：8845ABF3
或者
id1 = 0x8893CA58
msg1 = 0x3EAAAAA56A69AA55A95995A569AA95565556
msg2 = 0x3EAAAAA56A69AA556A965A5999596AA95656

def calc(msg):
    id=''
    s = bin(msg)[6:]
    for i in range(2, len(s), 2):
        if s[i-2:i] == s[i:i+2]:
            id += '0'
        else:
            id += '1'
    return hex(int(id, 2)).upper()

print(calc(msg1))
print(calc(msg2))
根据计算机网络报文首部的一些学习，这里我进行了类比，可能校验位应该是最后几位，依次尝试过都无果，但想到，除了最后2位不同，中间ID不同，其他均相同，可见校验位就是最后2位，那么校验位的计算应该是用CRC进行计算，而前面的位数是7位，尝试计算，但是得出的值并不是预计的。
后来想到可能缺位了，故又往前算了一位：
得到：024D 8893CA58 41 81和024D 8845ABF3 41 19
对024D 8893CA58 41和024D 8845ABF3 41进行CRC8运算

可以得到81和19，与猜想一致
下面就可以用这个方法解出flag
带入ID：DEADBEEF和BAADA555
得到：024D DEADBEEF 41
https://www.23bei.com/tool-233.html

024D BAADA555 41




计算CRC8，分别得到：B5和15
方法二：
也可以通过脚本获取：
#!/usr/bin/python

def crc(x,y):
   while(x>y):
      l = len(bin(x)) - len(bin(y))
      t = int(bin(y)[2:]+'0'*l,2)
      x ^= t
   return x
m = 0
for i in range(0x200):
   if i < 100:
      continue
   if crc(0x24d8893ca584100,i) == 0x81 and crc(0x24d8845abf34100,i) == 0x19:
      m = i
      print i
      break
print hex(crc(0x00024ddeadbeef4100,m))
print hex(crc(0x00024dbaada5554100,m))

最终得到flag:
flag{B515}