文章目录
0x00 写这篇博客的目的
对于CTF中的Misc来说，做题经验显得十分重要，而做题经验的获得很大一部分取决于刷题量。为了避免大家在刷题过程到处搜WriteUp浪费时间，现在把我的一些做题方法分享出来，希望对大家有帮助。当然，大家有更好的解决方法欢迎在评论区留言，互相学习，共同进步。
0x01 解题步骤
1.János-the-Ripper
a.拿到手是一个没有后缀的文件，常规操作先扔到kali中识别一下文件的类型，
一般来说，大佬们习惯放进winhex中看文件头，我8大星，我就放进winhex中。
b.放进kali中得知这是一个压缩包，解压
c.解压过程中发现图压缩包存在密码，无法正常解压出来，首先试一下是不是伪加密，伪加密的解决方法有好多，包括在winhex改十六进制等等的一些方法，而我在这里推荐一种比较简单的方法，在winrar中使用自动修复即可修复伪加密。
修复以后还是需要密码，那么也就是说不存在伪加密的这个现象
d.接下来爆破一下密码
比较轻松的就把密码爆破出来了
e.然后解压出里面的文件得到flag
2.2017_Dating_in_Singapore
a.由题目和一大串字符想到是类似日历的东西
b.找了份17年的日历根据所给的字符可以描出flag
c.出题人脑洞是真的大
3. 神奇的Modbus
a.拿到手是一个流量包，根据提示是modbus协议
b.过滤一下存在modbus的协议
c.追踪一下tcp流发现flag
d.得到了这个falg之后呢，一直提交不上，但是我在网上查找其他的writeup也是这么说的，有解决的师傅评论区指点我一下。
4. 4-1
a.拿到手是一个图片，首先放入winhex中走个形式查找一下flag，并且看一下有没有别的可疑的地方
b.虽然没有查找到flag但是从winhex中可以看到图片中是包含其他文件的，放入kali中foremost分离一下
c.分离出来其中存在一个zip文件 ，解压一下，最终得到两张照片。
d.两张照片的话首先想到在stegsolve中比较一下或者是盲水印攻击
e.在stegsolve中打开比较一下
发现有条纹状的东西，怀疑是盲水印攻击
f.在这里介绍一下盲水印攻击的使用方法
提取图片中的盲水印：
python bwm.py decode 无水印图片 有水印图片 提取出的图片
合成盲水印图片：
python bwm.py encode 无水印图片 水印 有水印图片
根据提示图片2应该是包含水印的图片，提取一下得到结果
5. 5-1
a.拿到文件没有后缀，把它放入kali中是一个二进制文件，在winhex中和binwalk都没有什么收获。
b.这其实是一个需要异或的文件
c.使用xortool异或得到key
尝试出了key：GoodLuckToYou，对原文件进行异或，脚本如下：
key = 'GoodLuckToYou'
flag = ''
with open('cipher') as f:
con = f.read()
for i in range(len(con)):
flag += chr(ord(con[i]) ^ ord(key[i%13]))
f = open('flag.txt', 'w')
f.write(flag)
f.close()
注意脚本运行环境是在python2中
6.MISCall
a.文件下载下来没有后缀，放进kali中得知是一个压缩包文件，加后缀名为zip然后解压
b.同样的方法解压后发现是一个ctf文件，有一个txt文件但里面没有flag，但是看见一个.git文件
c.git log(查看git记录)
d.git stash list（查看修改列表）
存储列表应该是有东西的
e.git stash show(校验一下列表中的存储文件)
f.git stash apply(重新储存，把上面的文件复原)
这样就得到了flag.txt和s.py，运行s.py即得flag。
7、can_has_stdio?
a.文件下载后解压是一个无后缀文件，先随手用notepad++打开
b.明显的brainfuck编码
解码方法可以在线解码也可以使用工具解码
c.补充一下brainfuck的编码知识
8. 3-1
a.到手文件没有后缀，放进kali中发现是rar压缩文件，改后缀解压，发现又是一个没有后缀的文件，放进kali发现是一个流量包
b.使用wireshark打开这个流量包。搜索字符串（flag）发现存在一个压缩包
把这个压缩包先分离出来
c.导出http流，发现存在三个文件
这个压缩包还是加密过的，并不是伪加密，其他的两个文件并没有发现相关密码的东西，那么现阶段的目标就变成了找出这个压缩包的密码
d.把目光重新的放到wireshark中，一个一个追踪流，但我觉得这个方法超极笨，有效率高的方法欢迎师傅们评论，在其中的一个tcp流中发现有系统命令。
根据命令得知存在四个文件，其中这个1文件就是压缩包，2文件是一个base64，3文件是一个加密脚本
e.修改3中加密脚本如下
# coding:utf-8
__author__ = 'YFP'
from Crypto import Random
from Crypto.Cipher import AES
import sys
import base64
V = '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))
str = '19aaFYsQQKr+hVX6hl2smAUQ5a767TsULEUebWSajEo=' #文件2中的base64
print(decrypt(base64.b64decode(str)))
f.跑一下脚本的到flag
9.适合作为桌面
a.拿到手是一个压缩包，解压后是一张图片
b.常规操作使用winhex，notepad++，binwalk检测没有收获，使用stegsolve查看发现二维码
c.使用qrcode扫描出二维码是一串十六进制的字符，开头为03 F3 0D 0A，这是一个python反编译的.pyc文件的十六进制文件头。
d.把它放到winhex中还原一下，后缀改成.pyc
e.反编译，执行命令uncompyle6 PYC反编译.pyc
f.运行一下反编译出来的脚本得到flag
10.warmup
a.下载得到一张图片和一个压缩包，发现压缩包中存在密码，尝试在图片中寻找解压密码，并没有找到
b.考虑明文攻击，将图片压缩成zip文件，看一下crc32的值
两个值相同，那么可以肯定就是从明文攻击入手，使用archpr进行明文攻击
恢复后一个文件夹中有两个一样的照片，在stegsolve中比较一下发现有条纹，大概率是盲水印，进行盲水印攻击
得到水印图
11.simple_transfer
a.到手是一个流量包，放进wireshark中打开一波分析后并没有分析出什么东西来，只看到一个一个pdf样式的东西，断断续续的。
b.自己流量分析水平实在是low的一匹，干脆放到kali中foremost一下，结果把这个pdf分离出来了
六个金币的题目就这样一个foremost到手了，慌的一匹。
12.Banmabanma
a.到手一个斑马的图片，观察发现斑马的身上是条形码
b.为了便于扫描条形码，我们把条形码上下都拉长一点，这里有个小技巧，在画图软件中打开图片，使用虚线框住，然后按住alt+上下键就可以在上或者下方拉长图片。最后得到这么一个图片。
虽然奇丑，已经没有马的样子，选取中间完整的部分截取出来放到bctester工具里识别一下就得到了flag。也可以使用在线识别网站
13. Just-No-One
a.在安装的那一段文本中找flag
这就是flag
14.我们的秘密是绿色的
a.到手是一张图片，一番尝试后无果继续看一下题目，我们的秘密是绿色的，刚好有一个工具的名字叫做our secret，使用our secret打开，发现需要密码，在刚开始的一番尝试中并没有发现什么像是密码的东西。
b.尝试图片上的绿色的数字，把它作为密码。
0405111218192526
成功得到一个名为try的压缩包
c.解压压缩包，需要密码，提示是生日，那么进行六位数字的密码爆破，没有找到密码，继续尝试一下八位数字的密码爆破。成功获得密码
d.解压后，又是一个压缩包，也是需要密码，并且发现，里外都有相同的文件
比较像是明文攻击
e.把readme.txt使用winrar压缩成zip，使用archpr进行明文攻击，得到密码
Y29mZmVl
f.解压得到flag.zip解压竟然还需要密码。。。。。无fuck说了，没有提示，也没相同的文件，先考虑一下伪加密把，winhex把01改成00，关于伪加密的知识可以参考一下这个师傅写的博客。
g.成功得到文本文件，先栅栏后凯撒得到flag。
15.Erik-Baleog-and-Olaf
http://taskcode3.cn/?p=116
这个题目倒是不难，但是要修复这个图片就太难了，附上一个链接
16.py-py-py
a.到手是一个.pyc文件，把它反编译一下
[外链图片转存失败(img-5gIXrijm-1569205782128)(en-resource://database/753:1)]
反编译后的代码
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]:
pass
return result[26:]
else:
return
else:
return keyc + base64.b64encode(result)
if __name__ == '__main__':
while True:
flag = raw_input('Please input your flag:')
if flag == crypto(fllag, 'decode'):
print('Success')
break
else:
continue
可以看出进行了rc4加密，ddd就是key
b.rc4算法脚本
# /usr/bin/python# coding=utf-8import sys, os, hashlib, time, base64
def rc4(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) and result[10:26] == hashlib.md5(
result[26:] + keyb).hexdigest()[0:16]:
return result[26:]
else:
return None
else:
return keyc + base64.b64encode(result)
if __name__ == '__main__':
string = '我在这里呢，你在那里呢'
print(string)
str = rc4(string, 'encode')
print(str)
fllag = '9474yeUMWODKruX7OFzD9oekO28+EqYCZHrUjWNm92NSU+eYXOPsRPEFrNMs7J+4qautoqOrvq28pLU='
rc = rc4(fllag, 'decode')
print(rc)
这个脚本在python2中运行
运行结果
提示需要Steganography这个工具来解决
c.使用脚本
import argparse
import logging
import marshal
import opcode
import os
import py_compile
import sys
import math
import string
import types
print ('usage: python Stegosaurus.py -h')
print ('usage: python Stegosaurus.py 1.pyc -x')
if sys.version_info < (3, 6):
sys.exit("Stegosaurus requires Python 3.6 or later")
class MutableBytecode():
def __init__(self, code):
self.originalCode = code
self.bytes = bytearray(code.co_code)
self.consts = [MutableBytecode(const) if isinstance(const, types.CodeType) else const for const in code.co_consts]
def _bytesAvailableForPayload(mutableBytecodeStack, explodeAfter, logger=None):
for mutableBytecode in reversed(mutableBytecodeStack):
bytes = mutableBytecode.bytes
consecutivePrintableBytes = 0
for i in range(0, len(bytes)):
if chr(bytes[i]) in string.printable:
consecutivePrintableBytes += 1
else:
consecutivePrintableBytes = 0
if i % 2 == 0 and bytes[i] < opcode.HAVE_ARGUMENT:
if consecutivePrintableBytes >= explodeAfter:
if logger:
logger.debug("Skipping available byte to terminate string leak")
consecutivePrintableBytes = 0
continue
yield (bytes, i + 1)
def _createMutableBytecodeStack(mutableBytecode):
def _stack(parent, stack):
stack.append(parent)
for child in [const for const in parent.consts if isinstance(const, MutableBytecode)]:
_stack(child, stack)
return stack
return _stack(mutableBytecode, [])
def _dumpBytecode(header, code, carrier, logger):
try:
f = open(carrier, "wb")
f.write(header)
marshal.dump(code, f)
logger.info("Wrote carrier file as %s", carrier)
finally:
f.close()
def _embedPayload(mutableBytecodeStack, payload, explodeAfter, logger):
payloadBytes = bytearray(payload, "utf8")
payloadIndex = 0
payloadLen = len(payloadBytes)
for bytes, byteIndex in _bytesAvailableForPayload(mutableBytecodeStack, explodeAfter):
if payloadIndex < payloadLen:
bytes[byteIndex] = payloadBytes[payloadIndex]
payloadIndex += 1
else:
bytes[byteIndex] = 0
print("Payload embedded in carrier")
def _extractPayload(mutableBytecodeStack, explodeAfter, logger):
payloadBytes = bytearray()
for bytes, byteIndex in _bytesAvailableForPayload(mutableBytecodeStack, explodeAfter):
byte = bytes[byteIndex]
if byte == 0:
break
payloadBytes.append(byte)
payload = str(payloadBytes, "utf8")
print("Extracted payload: {}".format(payload))
def _getCarrierFile(args, logger):
carrier = args.carrier
_, ext = os.path.splitext(carrier)
if ext == ".py":
carrier = py_compile.compile(carrier, doraise=True)
logger.info("Compiled %s as %s for use as carrier", args.carrier, carrier)
return carrier
def _initLogger(args):
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logger = logging.getLogger("stegosaurus")
logger.addHandler(handler)
if args.verbose:
if args.verbose == 1:
logger.setLevel(logging.INFO)
else:
logger.setLevel(logging.DEBUG)
return logger
def _loadBytecode(carrier, logger):
try:
f = open(carrier, "rb")
header = f.read(12)
code = marshal.load(f)
logger.debug("Read header and bytecode from carrier")
finally:
f.close()
return (header, code)
def _logBytesAvailableForPayload(mutableBytecodeStack, explodeAfter, logger):
for bytes, i in _bytesAvailableForPayload(mutableBytecodeStack, explodeAfter, logger):
logger.debug("%s (%d)", opcode.opname[bytes[i - 1]], bytes[i])
def _maxSupportedPayloadSize(mutableBytecodeStack, explodeAfter, logger):
maxPayloadSize = 0
for bytes, i in _bytesAvailableForPayload(mutableBytecodeStack, explodeAfter):
maxPayloadSize += 1
logger.info("Found %d bytes available for payload", maxPayloadSize)
return maxPayloadSize
def _parseArgs():
argParser = argparse.ArgumentParser()
argParser.add_argument("carrier", help="Carrier py, pyc or pyo file")
argParser.add_argument("-p", "--payload", help="Embed payload in carrier file")
argParser.add_argument("-r", "--report", action="store_true", help="Report max available payload size carrier supports")
argParser.add_argument("-s", "--side-by-side", action="store_true", help="Do not overwrite carrier file, install side by side instead.")
argParser.add_argument("-v", "--verbose", action="count", help="Increase verbosity once per use")
argParser.add_argument("-x", "--extract", action="store_true", help="Extract payload from carrier file")
argParser.add_argument("-e", "--explode", type=int, default=math.inf, help="Explode payload into groups of a limited length if necessary")
args = argParser.parse_args()
return args
def _toCodeType(mutableBytecode):
return types.CodeType(
mutableBytecode.originalCode.co_argcount,
mutableBytecode.originalCode.co_kwonlyargcount,
mutableBytecode.originalCode.co_nlocals,
mutableBytecode.originalCode.co_stacksize,
mutableBytecode.originalCode.co_flags,
bytes(mutableBytecode.bytes),
tuple([_toCodeType(const) if isinstance(const, MutableBytecode) else const for const in mutableBytecode.consts]),
mutableBytecode.originalCode.co_names,
mutableBytecode.originalCode.co_varnames,
mutableBytecode.originalCode.co_filename,
mutableBytecode.originalCode.co_name,
mutableBytecode.originalCode.co_firstlineno,
mutableBytecode.originalCode.co_lnotab,
mutableBytecode.originalCode.co_freevars,
mutableBytecode.originalCode.co_cellvars
)
def _validateArgs(args, logger):
def _exit(msg):
msg = "Fatal error: {}\nUse -h or --help for usage".format(msg)
sys.exit(msg)
allowedCarriers = {".py", ".pyc", ".pyo"}
_, ext = os.path.splitext(args.carrier)
if ext not in allowedCarriers:
_exit("Carrier file must be one of the following types: {}, got: {}".format(allowedCarriers, ext))
if args.payload is None:
if not args.report and not args.extract:
_exit("Unless -r or -x are specified, a payload is required")
if args.extract or args.report:
if args.payload:
logger.warn("Payload is ignored when -x or -r is specified")
if args.side_by_side:
logger.warn("Side by side is ignored when -x or -r is specified")
if args.explode and args.explode < 1:
_exit("Values for -e must be positive integers")
logger.debug("Validated args")
def main():
args = _parseArgs()
logger = _initLogger(args)
_validateArgs(args, logger)
carrier = _getCarrierFile(args, logger)
header, code = _loadBytecode(carrier, logger)
mutableBytecode = MutableBytecode(code)
mutableBytecodeStack = _createMutableBytecodeStack(mutableBytecode)
_logBytesAvailableForPayload(mutableBytecodeStack, args.explode, logger)
if args.extract:
_extractPayload(mutableBytecodeStack, args.explode, logger)
return
maxPayloadSize = _maxSupportedPayloadSize(mutableBytecodeStack, args.explode, logger)
if args.report:
print("Carrier can support a payload of {} bytes".format(maxPayloadSize))
return
payloadLen = len(args.payload)
if payloadLen > maxPayloadSize:
sys.exit("Carrier can only support a payload of {} bytes, payload of {} bytes received".format(maxPayloadSize, payloadLen))
_embedPayload(mutableBytecodeStack, args.payload, args.explode, logger)
_logBytesAvailableForPayload(mutableBytecodeStack, args.explode, logger)
if args.side_by_side:
logger.debug("Creating new carrier file name for side-by-side install")
base, ext = os.path.splitext(carrier)
carrier = "{}-stegosaurus{}".format(base, ext)
code = _toCodeType(mutableBytecode)
_dumpBytecode(header, code, carrier, logger)
if __name__ == "__main__":
main()
使用命令：python 脚本 需要提取的pyc文件 -x
得到flag
17.mysql
a.到手是一个压缩包，把压缩解压后有两个文件，其中一个是文件夹，打开文件夹在notepad++里查看文件内容，根据题目提示，存储了flag，那么在文件中查询flag。
b.一个文件一个文件的找，当找到ib_logfile0这个文件的时候，查询到了flag
后面这一串就是flag，这也算是个非预期解了。
18.Reverse-it
a.拿到题后，一番尝试无果，继续在winhex中查看有什么端倪，结合题目的提示，Reverse-it，也就是反向的意思
b.看一下文件的末尾
反过来也就是FFD8也就是jpg的文件头，开头是
也就是jpg的文件尾
c.把里面的十六进制数值复制出来，进行字符反转，然后写入winhex中保存为jpg格式得到一张图片
虽然是反着的，但也可以读出flag了。
