攻防世界misc前5页做题记录

做这个记录主要是给学弟参考的，不知不觉写了挺多的就发出来一起学习，记录不易，需要转载的话请标注来源

low

低位隐写

import PIL.Image as image

img = image.open(r'C:\Users\Administrator\Downloads\攻防世界\low\low.bmp')
img_tmp = img.copy()
pix = img_tmp.load()
w, h = img_tmp.size
for i in range(w):
    for j in range(h):
       if pix[i,j]&1 == 0:
           pix[i,j]=0
       else:
           pix[i,j]=255

img_tmp.save(r'C:\Users\Administrator\Downloads\攻防世界\low\a.png')

适合作为桌面

03F30D0A79CB05586300000000000000000100000040000000730D0000006400008400005A000064010053280200000063000000000300000016000000430000007378000000640100640200640300640400640500640600640700640300640800640900640A00640600640B00640A00640700640800640C00640C00640D00640E00640900640F006716007D00006410007D0100781E007C0000445D16007D02007C01007400007C0200830100377D0100715500577C010047486400005328110000004E6966000000696C00000069610000006967000000697B000000693300000069380000006935000000693700000069300000006932000000693400000069310000006965000000697D000000740000000028010000007403000000636872280300000074030000007374727404000000666C6167740100000069280000000028000000007304000000312E7079520300000001000000730A0000000001480106010D0114014E280100000052030000002800000000280000000028000000007304000000312E707974080000003C6D6F64756C653E010000007300000000
# 16进制查看，发现是python的编译文件，拿去反编译

def flag():
    str = [102,108,97,103,123,51,56,97,53,55,48,51,50,48,56,53,52,52,49,101,55,125]
    flag = ''
    for i in str:
        flag += chr(i)
    print(flag)
# flag{38a57032085441e7}

4433

红色第一通道下发现二维码，扫出 …–.----…–…

联系题目4433截取摩斯，解码出 VYGUD，提交错误，然后麻了，这玩意代表 VERYGOOD

traffic

注意到少量的 ICMP协议，猜测就是和 Data的长度有关，提取出来

a = [100, 106, 95, 101, 121, 47, 65, 107, 78, 69, 62, 75, 49, 123]
flag = ""
for i in a:
    flag += chr(i + 2)
print(flag)
# flag{1CmPG@M3}

第四扩展FS

foremost 分离出一个zip，带密码，exiftool发现图片注释 Pactera，解码出来的东西很乱但是还是有规律的，像是词频

alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*()_+- =\\{\\}[]"
strings = open(r'C:\Users\Administrator\Downloads\攻防世界\第四扩展FS\file.txt', encoding='utf-8').read()

result = {}
for i in alphabet:
    counts = strings.count(i)
    i = '{0}'.format(i)
    result[i] = counts
res = sorted(result.items(), key=lambda item: item[1], reverse=True)
for data in res:
    print(data)
for i in res:
    flag = str(i[0])
    print(flag[0], end="")
# DCTF{ka1f4NgxIntAi}bcdehjlmopqrsuvwyzBEGHJKLMOPQRSUVWXYZ23567890!@#$%^&*()_+- =\[]
# 这里注意一下，flag给的有问题，明明就是DCTF{ka1f4NgxIntAi}但却错误的，DCTF{ka1f4NgxlntAi}这个正确

misc1

d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9e1e6b3e3b9e4b3b7b7e2b6b1e4b2b6b9e2b1b1b3b3b7e6b3b3b0e3b9b3b5e6fd

第一眼就知道是16进制拿去试乱码没那么简单，发现这些16进制都很大，如果是ascii的话16进制最多不超过80这些显然超过了所以取余

src = """d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9e1e6b3e3b9e4b3b7b7e2b6b1e4b2b6b9e2b1b1b3b3b7e6b3b3b0e3b9b3b5e6fd"""
new_src = ""
for i in range(0,len(src),2):
    data = src[i:i+2]
    new_data = int(data,16)%128
    new_src += chr(new_data)
print(new_src)
# That was fast! The flag is: DDCTF{9af3c9d377b61d269b11337f330c935f}

picture

010往下拉发现多余数据，binwalk提取出来是个zlib文件，解压出base64拿去解码，调换PK位置是压缩包，需要密码

密码与ZeroDivisionError有关，也就是除0错误 integer division or modulo by zero，拿到密码

打开这个G0TE30TY[,C,X.$%&,C@Y,T5".#5%0C%"-#,Y04)&1C8Q-S,Q.49]，不知道是个啥，了解到这是Unencode编码

Unencode

UUencode的加密方式和base64很相似，但他的编码表有很多是特殊字符:"!#￥%&'()*+= 等等。UUencode(1234567)=',3(S-#4V-P``，另外注意到一些在线的编码器编码都有个特点，就是最后会换一行打个撇点，这题后面也有，不知道可不可以作为判断依据

Run

分类是misc，这不是一道web吗

沙箱逃逸

a= ().__class__.__bases__[0].__subclasses__()[59].__init__.__getattribute__('__global'+'s__')['s'+'ys'].modules['o'+'s'].__getattribute__('sy'+'stem')

a('/bin/sh')

pypypy

给的pyc文件，拿去反编译出来并没发现什么有用的信息，了解到这里是pyc的stegosaurus隐写，记录一下

stegosaurus Pyc隐写

Stegosaurus是一个隐写工具，允许在Python字节码（pyc或pyo）文件中嵌入任意有效载荷。嵌入过程不会改变载体文件的运行时行为或文件大小，并且通常会导致编码密度低。有效负载分散在整个字节码中，因此像这样的工具不会显示实际的有效负载

项目地址 https://github.com/AngelKitty/stegosaurus

学习地址 https://www.anquanke.com/post/id/225344

高版本python会报错，我这里换的python3.7

侧信道初探

不是很懂这个，就看过ctf_wiki上一点讲这个的，密码学板块的，SCTF{0110111010}

https://yangtf.gitee.io/ctf-wiki/crypto/asymmetric/rsa/rsa_side_channel/

肥宅快乐题

是个flash动画，直接一帧一帧的看就会发现，base64

神奇的Modbus

Noise

找到歌曲原声，然后比对去背景声，保留杂音，杂音用SSTV打开，是的无线电传的张图片

picture1

LSB加密，直接提取出来，密码就是图片拼音的首字母，提取出是 DES加密

DES加密

项目地址 https://github.com/liupengs/DES_Python

keyword

丢到stegsolve在RGB的0通道发现不同，猜测存在lsb隐写

LSB加密

项目地址 https://github.com/livz/cloacked-pixel

提取出PVSF{vVckHejqBOVX9C1c13GFfkHJrjIQeMwf}，根据keyword提示关键字密码，注意这里还要改一下大小要写一致

keyword密码

我萌吗

打CTF的妹子超酷的好吗，

拿到提到的这个文件js美化一下

function encode(flag, path, keySrc, dest, dest2) {
  for (
    var used = [],
      relPosition = [],
      jpegData = fs.readFileSync(path),
      ks = fs.readFileSync(keySrc),
      pngtool = new pp(jpegData),
      key = new pp(ks),
      picSize = pngtool.size(),
      pixelNum = picSize.width * picSize.height,
      i = (new Buffer(4 * pixelNum), 0);
    i < flag.length;
    i++
  )
    for (temp = Math.floor(pixelNum * Math.random()); ; ) {
      if (!used.includes(temp)) {
        used.push(temp), relPosition.push(i);
        break;
      }
      temp = (temp + 1) % Math.floor(pixelNum);
    }
  for (i = 0; i < picSize.height; i++)
    for (var j = 0; j < picSize.width; j++) {
      var addrIndex = used.findIndex(function (item) {
          return item === i * picSize.width + j;
        }),
        flagIndex = relPosition[addrIndex];
      if (-1 !== addrIndex) {
        var temp = pngtool.get(j, i);
        100 * Math.random() > 50 && !used.includes(j * picSize.width + i)
          ? (pngtool.set(j, i, {
              r: 255 - temp.r,
              g: 255 - temp.g,
              b: 255 - temp.b,
              a: temp.a
            }),
            key.set(i, j, {
              r: temp.r,
              g: flagIndex,
              b: flag.charCodeAt(flagIndex)
            }))
          : (pngtool.set(j, i, {
              r: temp.r,
              g: flagIndex,
              b: 255 - temp.b,
              a: temp.a
            }),
            key.set(j, i, {
              r: temp.r,
              g: flag.charCodeAt(flagIndex),
              b: temp.b,
              a: temp.a
            }));
      }
    }
  pngtool.save(dest, function (e) {
    console.log(e);
  }),
    key.save(dest2, function (e) {
      console.log(e);
    });
}
var pp = require("png-img"),
  fs = require("fs"),
  flag = "5L2g5LiN5Lya5Lul5Li66L+Z5piv562U5qGI5ZCnPw==";
encode(flag, "1.png", "ks.png", "dest.png", "key.png");
//如果你找到了这个文件，恭喜你，就真的成送分题了

逆向decode

function decode(path, dest, dest2){
	var flag=[];
	var relPosition = [], 
	 f1 = fs.readFileSync(path), 
	 d1 = fs.readFileSync(dest), 
	 d2 = fs.readFileSync(dest2),
	 ff1 = new pp(f1), 
	 dd1 = new pp(d1), 
	 key = new pp(d2),
	 picSize = ff1.size(), 
	 pixelNum = picSize.width * picSize.height;
	 for (i = 0; i < picSize.height; i++) 
		for (var j = 0; j < picSize.width; j++) 
		{
			var t1=ff1.get(j, i);
			var t2=dd1.get(j,i);
			if((t1.b-t2.b)!=0)
			{
				if((t1.r-t2.r)==0)
				{
					var k1=key.get(j,i);
					flag[t2.g]=String.fromCharCode(k1.g);

				}else{
					var k1=key.get(i,j);
					flag[k1.g]=String.fromCharCode(k1.b);
				}
			}
		}
	console.log(flag);
}
decode("1.png","dest.png","key.png");
// b25seSBjYXQgd2lsbCBkZWNvZGUgdGhpczIzMzMzMzM=
// base64一下only cat will decode this2333333

小小的PDF

010查看发现是有3张图片的，文件打开只能看见2张，所以提取第3张的16进制字节流出来 SYC{so_so_so_easy}

2017_Dating_in_Singapore

01081522291516170310172431-050607132027262728-0102030209162330-02091623020310090910172423-02010814222930-0605041118252627-0203040310172431-0102030108152229151617-04050604111825181920-0108152229303124171003-261912052028211407-04051213192625

这个就没啥好说的了，新加坡2017年的日历

Cephalopod

Flying_High

解压出4个UBIFS文件，挂载读取内容

UBIFS文件

UBIFS是一个闪存文件系统，这意味着它被设计为与闪存设备一起使用。重要的是要了解，UBIFS与Linux中的任何传统文件系统完全不同，如Ext2，XFS，JFS等。UBIFS表示一类单独的文件系统，它们与MTD设备一起使用，而不是块设备。

项目地址 https://github.com/jrspruitt/ubi_reader

在ext3中发现一段视频，里面就是flag

simple_transfer

binwalk发现pdf，提取出来

Excaliflag

santa-walks-into-a-bar

还有一万个二维码，人都麻了，逐个爆破flag也不是不行，官方给的解法是从这个ID开始逐个扫二维码

太麻烦了，我直接暴力点全扫了，Y0ur gift is in goo.gl/wFGwqO inugky3leb2gqzjanruw42yk

from PIL import Image
from pyzbar import pyzbar
import os
filepath = r'C:\Users\Administrator\Downloads\攻防世界\santa-walks-into-a-bar\list'
pathDir = os.listdir(filepath)
count = 1
for chrildDir in pathDir:
    try:
        path = "{}\\{}".format(filepath, chrildDir)
        img = Image.open(path)
        data = str(pyzbar.decode(img)[0].data).split(' ')[5].replace("'",'')
        print(count,data)
        count += 1
    except Exception:
        pass

# 逐个扫也行，反正一万张图片也不多，需要的时间都差不多
filepath = r'C:\Users\Administrator\Downloads\攻防世界\santa-walks-into-a-bar\list'
count = 1
data = '7ab7df3f4425f4c446ea4e5398da8847'
try:
    while True:
        path = "{}\\{}".format(filepath, data+'.png')
        img = Image.open(path)
        data = str(pyzbar.decode(img)[0].data).split(' ')[5].replace("'", '')
        print(count, data)
        count += 1
except Exception:
    print("找到了")
    exit()
# goo.gl这个服务器已经关掉了，所以这里直接给flag，看的韩国老外博客知道的flag
# 3DS{I_h0p3_th4t_Y0u_d1d_n0t_h4v3_ch4ck3d_OnE_by_0n3}

jpg

010打开发现rar，作为16进制字节提取出来，解压有密码试试爆破，密码123456

得到一个文件，内容是大量的base64，文件名base64解码是flag.code，内容解码保存为16进制文件，这一串像是flag异或

这里卡住了看wp知道确实是异或了，flag=orz_u_Get_The.C0D3_F1@9

Pixel-Princess

foremost出两张图片，发现密码 passphrase:BaD_DR4G0N

Steghide隐写

Steghide是隐写术程序隐藏的数据文件 在一些最低有效位的另一个文件以这样一种方式 数据文件的存在是不可见的,不能证明。

Steghide被设计成藏便携和可配置和特性 数据在bmp, jpeg, wav和非盟文件,河豚加密、MD5散列 河豚密钥密码,伪随机分配隐藏的部分 容器中的数据。

hong

给了段音频还以为很复杂，音频编辑软件一直报错以为被改了哪里，binwalk发现藏图片了，就是flag

至于那个二维码，扫出来是段16进制字节，保存下来python反编译，Mr.Hong 啥玩意

misc_pic_again

LSB隐写，zsteg检查一下就可以发现通道藏了zip，提取出来zsteg 719af25af2ca4707972c6ae57060238e.png -e b1,rgb,lsb,xy > a.zip

hctf{scxdc3tok3yb0ard4g41n~~~}

摩斯电码

音频摩斯

在线网站 https://morsecode.world/international/decoder/audio-decoder-adaptive.html

blocks

分离出一张二维码但是扫不出什么，二维码可能只有部分吧，然后在Alpha的0通道发现一个像是二维码的东西

这里又卡住了，提取出来以后没什么东西和思路了，先放个官方的脚本，这里异或和后面就不知道他在干嘛了

from PIL import Image

img = Image.open('stego_100_f78a3acde659adf7ceef546380e49e5f.png')
m1 = m2 = ''
for y in range(0, img.size[0], 19):
    for x in range(0, img.size[1], 19):
        r, g, b, a = img.getpixel((x, y))
        m1 += str(r & 1)
for y in range(171, 171 + 19):
    for x in range(171, 171 + 19):
        r, g, b, a = img.getpixel((x, y))
        m2 += str(a & 1)
xor = ''.join(str(int(A) ^ int(B)) for A, B in zip(m1, m2))
print(''.join(chr(int(xor[i:i + 8], 2)) for i in range(0, len(xor), 8)))
# flag  = ASIS_08213db585ffe1c93c8f04622c319594

3-1

压缩包提取出流量包，发现flag.rar，提取出流量，压缩包有密码，在TCP流6中发现AES加密流量

# 19aaFYsQQKr+hVX6hl2smAUQ5a767TsULEUebWSajEo=
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))

# 解密
src ='19aaFYsQQKr+hVX6hl2smAUQ5a767TsULEUebWSajEo='
print(decrypt(base64.b64decode(s)))
# passwd={No_One_Can_Decrypt_Me}，解压得到flag

3-2

打开是个二维码的GIF，很显然了，四帧图片放到一起才是完整的二维码，麻了用PPT拼图拼了半天，手工活不行还是直接跑脚本吧

from  PIL import Image

flag = Image.new("RGB",(450,450))
for i in range(2):
    for j in range(2):
        pot = r"C:\Users\Administrator\Downloads\攻防世界\3-2\frame{}.bmp".format(j+i*2+1)
        potImage = Image.open(pot)
        crop = potImage.crop(((j * 225, i * 225, (j+1)*225, (i+1)*225)))
        flag.paste(crop, (j * 225, i * 225))
#flag.save(r'C:\Users\Administrator\Downloads\攻防世界\3-2\flag.png')
img = Image.open(r'C:\Users\Administrator\Downloads\攻防世界\3-2\flag.png')
data = pyzbar.decode(img)
print(data[0].data)

16进制保存是pyc文件，拿去反编译

import random
key = 'ctf'
strr = '186,98,180,154,139,192,114,14,102,168,43,136,52,218,85,100,43'

def func1(str1, key):
    random.seed(key)
    str2 = ''
    for c in str1:
        str2 += str(ord(c) ^ random.randint(0, 255)) + ','
    str2 = str2.strip(',')
    return str2
def func2(str2, key):
    random.seed(key)
    str1 = ''
    for i in str2.split(','):
        i = int(i)
        str1 += chr(i ^ random.randint(0, 255))
    return str1

# 解密
print(func2(strr,key))
# flag{U_r_Greatt!}

4-1

提取出两张一样的图片，正好也对应了tip：Although two days doing the same things, but day2 has a secret than day1

盲水印

主要在于傅里叶变换把原图变为频谱图，再叠加水印，将含水印的频谱图进行傅里叶逆变换得到含水印的图像

项目地址 https://github.com/chishaxie/BlindWaterMark

py2和py3的加解密结果会有所不同，主要原因是py2和py3 random的算法不同，要让py3兼容py2的random算法加 --oldseed

4-2

Eg qnlyjtcnzydl z umaujejmjetg qeydsn eu z bsjdtx tw sgqtxegc al kdeqd mgeju tw yrzegjsoj zns nsyrzqsx kejd qeydsnjsoj Ew ltm fgtk jds kzl tw sgqtxegc m kerr csj jds wrzc kdeqd eu qrzuueqzr-qeydsn_eu_gtj_usqmnejl_du

词频替换密码

在线网站 https://quipqiup.com/

5-1

xortool

用来分析多字节异或密码，猜测密钥长度(基于数相同的字符)，猜测关键字(基于最频繁的字符）

项目地址 https://github.com/raddyfiy/xortool-for-Windows

加密命令
D:\xortool> python xortool-xor.py -f ./text/cmd.exe -s “secret_key” -n -o binary_xored_cmd
-f表示待加密的原文件，-s是密钥，-o是输出文件，不要用>重定向来保存
必须加上-n保证加密内容就是原本文件，不然会把原本文件加个-n再加密，这样解密出来的文件会多个\n。

解密命令
python xortool.py binary_xored_cmd -l 10 -c 00
-l就是指定密钥长度，-c表示出现频率较高的字符。
这个需要根据经验，文本内容一般是空格（20），二进制文件一般是00，不同的字符结果不同

95% 有一些差异，猜测秘钥是 GoodLuckToYou，然后对整个文件异或

import os

data = open(r"C:\Users\Administrator\Downloads\攻防世界\5-1\a",'r',errors='ignore').read()
key = "GoodLuckToYou"
keylen = len(key)
flag = ""
for i in range(len(data)):
    flag += chr(ord(key[i % keylen]) ^ ord(data[i]))
print(flag)
# wdflag{You Are Very Smart}

picture2

这里放错题了吧，和picture串了，一样的了

run1

一样同run

latlong

010看一眼是WAV，Au导入原始数据乱翻一通没有一点思路，这啥个玩意也没个提示的字眼，查了当时的原题有提示

Ax.25是那个无线电协议吗，完全不会，记录新知识

multimon-ng解码无线电

用C语言编写的一款无线电扫描频谱信号通信的软件，专门解码aprs、psk等业余无线电数字通信协议的工具

项目地址 https://github.com/EliasOenal/multimon-ng/

Kali Tool中也有集成，可以直接安装，sudo apt install multimon-ng

sox -t wav pocsag_short.wav -esigned-integer -b16 -r 22050 -t raw pocsag_short.raw

multimon-ng -t raw -a FMSFSK -a AFSK1200 pocsag_short.raw

stage1

绿色通道1发现二维码，直接扫是扫不出来的，这里需要反相一下

03F30D0AB6266A576300000000000000000100000040000000730D0000006400008400005A00006401005328020000006300000000030000000800000043000000734E0000006401006402006403006404006405006406006405006407006708007D00006408007D0100781E007C0000445D16007D02007C01007400007C0200830100377D0100712B00577C010047486400005328090000004E6941000000696C000000697000000069680000006961000000694C0000006962000000740000000028010000007403000000636872280300000074030000007374727404000000666C6167740100000069280000000028000000007307000000746573742E7079520300000001000000730A00000000011E0106010D0114014E280100000052030000002800000000280000000028000000007307000000746573742E707974080000003C6D6F64756C653E010000007300000000

python反编译

def flag():
 	str = [65, 108, 112, 104, 97, 76, 97, 98]
	flag = ''
 	for i in str:
 		flag += chr(i)
	print flag   

# AlphaLab

test.pyc

在线工具反编译出来的有点问题，报了个不全的错，用python的uncompyle6模块反编译再试一下，也显示反编译错误

str = 'jYygTOy' + 'cmNycWNyYmM1Ujf'
import base64

def flag1():
    code = str[::-3]
    result = ''
    for i in code:
        ss = ord(i) - 1
        result += chr(ss)
    print result[::-1]
def flag2():
    code = str[::-2]
    result = ''
    for i in code:
        ss = ord(i) - 1
        result += chr(ss)   
    print result[::-2]
def flag3():
    pass

flag1()

大概意思就是加载常量，以str变量名保存，然后取反，导入base64模块并且保存，然后加载另外3个函数

=cWbihGfyMzNllzZ0cjZzMWN5cTM4YjYygTOycmNycWNyYmM1Ujf
取反
fjU1MmYyNWcyNmcyOTgyYjY4MTc5NWMzZjc0ZzllNzMyfGhibWc=
base64
~552f25g26g2982b681795c3f74g9e732|hbmg
注意到 gmbh 与 flag 相差 1,所以就简单了

src = "~552f25g26g2982b681795c3f74g9e732|hbmg"
result = ""
for i in src:
    result += chr(ord(i)-1)
print(result[::-1])
# flag{126d8f36e2b486075a1781f51f41e144}

challenge_how_many_Vigenère

看题目名字也提示了是维吉尼亚，但是不知道密码，how_many所以需要爆破key长度了

维吉尼亚密码

维吉尼亚密码是在凯撒密码基础上产生的一种加密方法，它将凯撒密码的全部25种位移排序为一张表，与原字母序列共同组成26行及26列的字母表。另外，维吉尼亚密码必须有一个密钥，这个密钥由字母组成，最少一个，最多可与明文字母数量相等。

在线网站 https://www.guballa.de/vigenere-solver

ohihzkssefkmqxqbkihybnynvndzkdlqvhwhgywaftmeteecqprzjczvnmhnzwyasmlwbwvaqitejbfofycejjlcbpk
明文片段谷歌搜了一下是爱丽丝梦游仙境，Alice's Adventures in Wonderland
按照题目要求，用这个key加密 Alice's Adventures in Wonderland

神奇的压缩文件

给的压缩包直接解压出来就只有一个文件，大小1kb，一行字 Flag.zip behind me.

看到这个直觉告诉我肯定是数据流藏东西了，就像我藏后门也一样喜欢藏数据流，扫了一下发现确实是这样的

导出来的flag.zip感觉是无限套娃了，这都套多少层了，再看题目描述说里面并没有flag，应该是方向错了

010看看藏东西了没，拉到最下面发现不一样的地方

可能中间的空格 09 20有点规律吧，用 1 0替换，二进制长度98，按照7位一组可以分14组

src = "0909200909202009092020200909090909200920200909202009092009090909200D0A0909200909200909200909202009202020090920200909200909200909202009090D0A2009090920090920090909090920200920200909202009202009090909092009"
lis = []
result = ""
for i in range(0,len(src),2):
    lis.append(src[i:i+2])
for i in lis:
    if i == '20':
        result += '0'
    if i == '09':
        result += '1'
#print(len(result))
lis.clear()
for i in range(0,len(result),7):
    lis.append(result[i:i+7])

flag = ""
for i in lis:
    flag += chr(int(i,2))
print(flag)
# lctf{6d3677dd}

要啥有啥

首先这段流量快速看一下，可以发现大量的扫端口行为和FTP爆破行为，通过proftpd 连接上来，并且写马，另一台机器MSF连接

往下追踪Tcp流，发现请求了两张图片 whoami.jpg 和 xor.jpg

都提取出来，做异或

with open(r"C:\Users\Administrator\Downloads\a\whoami.jpg", 'rb') as f:
    p = f.read()
temp = ''
with open(r'C:\Users\Administrator\Downloads\a\xor.jpg', 'rb') as f:
    t = f.read()
for a, b in zip(t, p):
    temp +=  chr(ord(a) ^ ord(b))
    print temp

得到加密算法，编写解密脚本

m = "cc90b9054ca67557813694276ab54c67aa93092ec87dd7b539"
def process(a, b, m):
    return "".join(map(chr, map(lambda x: (x * a + b) % 251, map(ord, m.decode('hex')))))

for i in xrange(255):
    for j in xrange(255):
        if "{" in process(i, j, m)and "}" in process(i,j,m):
          print process(i, j, m)
# 得到 AES_key{FK4Lidk7TwNmRWQd}

除了http、ftp、tcp 协议以外，还有大量的DNS，过滤一下，提取出其中的base64拼接，用拿到的key去AES解密

OYzmTh2MGNclc5gALl+2lJ/xu58d4dAtidJc2w4dRhB1cuh/pXAt17QSjEIFMPiSE6w+DXpXJk9zm0FD39MGvwL4ZNpr2YndIPnjnb0W3xNeP+e5r//GhTYkNTdPo4xpT4d+HMihDB1mZNcQ8Gib69l5NlqC8PFjEeABWPfJezqG0LozsEjukHJOCMhVlRrirtkI7/ExFZAgH+G1i/gaw84nJ0DbGXQEpA2wySh6/iXeJD1ZYgt7jRgKLCL6CGggxsAEP9+m3QTZkxEitNqplA==
    
Mvw3nE7h3GtoC0xqGKmjboBW7h+WyH+QhJRd1EL+Qc7cgRAaVNYwWrWDMByHOIlSig+MvEg0GTihcnuNdgRpD4fgmEgjvAvScqJkQUes+Mxbi4NNkCv6YANnbGFbZSUVs3YbulPu6Xzj+/nBmJcOsti94BHja8Cjym4l2qpmIkjR6kONAs2e7uAkduLR1z

import base64
from Crypto.Cipher import AES
def decrypt(data, password):
    unpad = lambda s: s[0:-ord(s[-1])]
    iv = data[:16]
    cipher = AES.new(password, AES.MODE_CBC, iv)
    data = cipher.decrypt(data[16:])
    return data
if __name__ == '__main__':
    password = 'FK4Lidk7TwNmRWQd'
    encrypt_data1 = base64.b64decode(
  'OYzmTh2MGNclc5gALl+2lJ/xu58d4dAtidJc2w4dRhB1cuh/pXAt17QSjEIFMPiSE6w+DXpXJk9zm0FD39MGvwL4ZNpr2YndIPnjnb0W3xNeP+e5r//GhTYkNTdPo4xpT4d+HMihDB1mZNcQ8Gib69l5NlqC8PFjEeABWPfJezqG0LozsEjukHJOCMhVlRrirtkI7/ExFZAgH+G1i/gaw84nJ0DbGXQEpA2wySh6/iXeJD1ZYgt7jRgKLCL6CGggxsAEP9+m3QTZkxEitNqplA==')
    encrypt_data2 = base64.b64decode(
  'Mvw3nE7h3GtoC0xqGKmjboBW7h+WyH+QhJRd1EL+Qc7cgRAaVNYwWrWDMByHOIlSig+MvEg0GTihcnuNdgRpD4fgmEgjvAvScqJkQUes+Mxbi4NNkCv6YANnbGFbZSUVs3YbulPu6Xzj+/nBmJcOsti94BHja8Cjym4l2qpmIkjR6kONAs2e7uAkduLR1zH9')
    decrypt_data1 = decrypt(encrypt_data1, password)
    print 'decrypt_data1:\n', decrypt_data1
    decrypt_data2 = decrypt(encrypt_data2, password)
    print 'decrypt_data2:\n', decrypt_data2

所以 LCTF{CVE20153306A11_1n_0ne_Pcap}

Miscellaneous-200

给的一堆RGB的值，估计是个图片，61366行，猜测宽高

from ast import literal_eval
from PIL import Image

with open(r'C:\Users\Administrator\Downloads\攻防世界\Miscellaneous-200\flag.txt') as f:
    data = f.readlines()
    lit = [literal_eval(line) for line in data]
    """
    503 * 122
    1006 * 61
    """
    img = Image.new('RGB', (503, 122))
    index = 0
    for i in range(503):
        for j in range(122):
            img.putpixel([i, j], lit[index])
            index += 1
    img.show()

Miscellaneous-300

典型的压缩包套娃了，文件名作为压缩包解压密码，直接写脚本跑了

套娃压缩包

import zipfile

path = r'C:\Users\Administrator\Downloads\攻防世界\Miscellaneous-300\\'
zipname = path + '46783.zip'
while True:
    ts1 = zipfile.ZipFile(zipname)
    res = ts1.namelist()[0].split('.')[0]
    print(res)
    passwd = bytes(res, 'utf-8')
    ts1.extractall(path, pwd = passwd)
    zipname = path + ts1.namelist()[0]

在12475.zip 处报错，说明解压到尽头了，里面有个音频文件，有密码，爆破到密码 b0yzz

Avatar

给的图片进行了一番检查都没发现什么思路，就想到用 stegdetect来检查一下

stegdetect隐写检测

Stegdetect 主要用于分析JPEG文件。因此用Stegdetect可以检测到通过JSteg、JPHide、OutGuess、Invisible Secrets、F5、appendX和Camouflage等这些隐写工具隐藏的信息。

Stegdetect的目的是评估JPEG文件的DCT频率系数，把检测到的可疑JPEG文件的频率与正常JPEG文件的频率进行对比。频率对比结果的偏差很大则说明被检查文件存在异常，这种异常意味着文件中存在隐藏信息的可能性很大。

下载地址 https://www.bookofnetwork.com/2576/download/Download-Stegdetect-software-for-PC-free

-s 修改检测算法的敏感度，该值的默认值为1
    检测结果的匹配度与检测算法的敏感度成正比，算法敏感度的值越大，检测出的可疑文件包含敏感信息的可能性越大
-t 设置要检测哪些隐写工具（默认检测jopi）
    j 检测图像中的信息是否是用jsteg嵌入 
    o 检测图像中的信息是否是用outguess嵌入
    p 检测图像中的信息是否是用jphide嵌入
    i 检测图像中的信息是否是用invisible secrets嵌入

outguess

Outguess是一种通用的隐写工具，允许将隐藏信息插入到数据源的冗余位中。数据源的性质与外部测试的核心无关。该程序依赖于特定于数据的处理程序，这些处理程序将提取冗余位并在修改后将其写回。目前仅支持PPM（可移植像素贴图），PNM（可移植任何贴图）和JPEG图像格式，尽管只要提供处理程序，outgues就可以使用任何类型的数据。

对于 JPEG 图像，OutGuess 会保留基于频率计数的统计信息。因此，没有已知的统计测试能够检测隐写内容的存在。在将数据嵌入图像之前，OutGuess 系统可以确定可以隐藏的最大消息大小，同时仍然能够根据频率计数维护统计信息。

项目地址 https://github.com/resurrecting-open-source-projects/outguess

Hidden-Message

全是UDP协议，追踪UDP流

看不懂这干嘛用的，继续看流量，一共80个UDP数据包，都没什么差别的，注意到01 规律，假如8位一组的话

10110111100110101001011010001100100110101001000110011101100110101000110110011000
直接转是乱码，可能要做个互换，0变1,1变0，再试试
src = "10110111100110101001011010001100100110101001000110011101100110101000110110011000"
new_src = ""
for i in src:
    if i == "0":new_src += "1"
    else:new_src += '0'
lit = []
for i in range(0, len(new_src), 8):
    lit.append(new_src[i:i + 8])
flag = ""
for i in lit:
    flag += chr(int(i, 2))
print(flag)
# Heisenberg

Recover-Deleted-File

根据题目名字猜测应该是要恢复删除的镜像文件

extundelete文件恢复

-superblock 	指定分区的超级块信息此选项是默认的
--journal		显示块的日志信息
--after          后接时间，只恢复指定时间（时间戳）之后被删除的数据
extundelete /dev/sdb2 --after 123456789 --restore-all	# 恢复此时间后删除的所有文件
extundelete /dev/sda1 --restore-file initramfs-2.6.32-358.el6.x86_64.img	# 恢复指定文件
extundelete /dev/sdb2 --restore-directory /test		# 恢复/test文件夹

What-is-this

丢kali一看是压缩包，提取出两张差不多的图片，盲水印试试，好吧不是

StegSolve image combiner 图片拼接

工控文件分析

拿到一个docx文件，打开是一个机床的计划卡，没什么重要的东西，直接解压缩docx出来看也没什么特别的

回到010直接搜flag发现 ps文件，搜了下png文件头提取出来一张高糊的图 the flag is (3ijnhygvfr)H

可能是提取方式有问题，麻了，又看到 from png to jpx

然后就不会了，记录一下佬们的思路，flag到底是提交什么也不知道，这题真麻了

最离谱的来了，flag到底是什么

flag<3377> 这是什么鬼，这种格式

很普通的数独

25张图片，不知道干嘛，就想到 5 *5

有点二维码的意思，调整定位符的位置，1放到5,5放到21，21放到1，然后简单做个拼接涂黑就行

Vm0xd1NtUXlWa1pPVldoVFlUSlNjRlJVVGtOamJGWnlWMjFHVlUxV1ZqTldNakZIWVcxS1IxTnNhRmhoTVZweVdWUkdXbVZHWkhOWGJGcHBWa1paZWxaclpEUmhNVXBYVW14V2FHVnFRVGs9
大概7次base64
# flag{y0ud1any1s1}

很普通的Disco

查看频谱图，开头就和后面不太一样，所以猜测二进制在上面的是1，下面的0

src = "110011011011001100001110011111110111010111011000010101110101010110011011101011101110110111011110011111101"
print(len(src))
flag = ""
for i in range(0,len(src),7):
    flag += chr(int(src[i:i+7],2))
print(flag)
# flag{W0W*funny}

就在其中

先说说在流量里的发现，tcp流不多就挨个看了下，大概就是在登录FTP，然后传输了几个key和pdf，pdf有点意思

openssl

rsa加密，两个key都试一下，openssl rsautl -decrypt -in key.txt -inkey test.key.txt -out flag.txt

再见李华

结尾压缩包，没什么好说的直接爆破就行，密码 15CCLiHua，提交通过后看了下官方wp，脑洞真大

hint: 假如你是李华（LiHua)，收到乔帮主一封密信，没有任何特殊字符，请输入密码，不少于1000个字。同学，记得署名哦
没有任何特殊字符 -指密码中没有特殊字符
不少于1000个字 -指的是2进制的8，所以密码长度 > 8
记得署名 -指密码最后几位就是名字 LiHua

embarrass

strings misc_02.pcapng | grep {

pyHAHA

pyc文件丢去反编译报错，010查看果然有问题，序列是反的

flag = open(r'C:\Users\Administrator\Downloads\攻防世界\pyHAHA\flag.pyc','wb')
with open(r'C:\Users\Administrator\Downloads\攻防世界\pyHAHA\PyHaHa.pyc','rb') as f:
    flag.write(f.read()[::-1])

binwalk分离出一个音频，同时flag.pyc去掉后面的压缩包丢去python反编译，记得补上缺少的文件头 03F30D0A

from os import urandom

def generate(m, k):
    result = 0
    for i in bin(m ^ k)[2:]:
        result = result << 1
        if int(i):
            result = result ^ m ^ k
        if result >> 256:
            result = result ^ P
            continue
    return result

def encrypt(seed):
    key = int(urandom(32).encode('hex'), 16)
    while True:
        yield key
        key = generate(key, seed) + 0x3653C01D55L
        
def convert(string):
    return int(string.encode('hex'), 16)

P = 0x10000000000000000000000000000000000000000000000000000000000000425L
flag1 = 'ThIs_Fl4g_Is_Ri9ht'
flag2 = 'Hey_Fl4g_Is_Not_HeRe'
key = int(urandom(32).encode('hex'), 16)
data = open('data.txt', 'r').read()
result = encrypt(key)
encrypt1 = bin(int(data, 2) ^ eval('0x' + hex(result.next())[2:-1] * 22))[2:]
encrypt2 = hex(convert(flag1) ^ result.next())[2:-1]
encrypt3 = hex(convert(flag2) ^ result.next())[2:-1]
print 'flag1:', encrypt2
print 'flag2:', encrypt3
f = open('encrypt.txt', 'w')
f.write(encrypt1)
f.close()

密码加密算法看不懂先放着，看提取出来的音频文件，发现一段不知道是什么的密文

163 key(Don't modify):L64FU3W4YxX3ZFTmbZ+8/dx5jBNDPdsKv9gAgXYyj0/Z0Vl4ORaCLH5D0oN9v9nBBv6zxpBucgNeE2qqke4ugZs7dxriT5lfUpulX5PYMzSg2pqL6APTHQjtIHw16ZCRTMBBkInrUGSTklA2MwPLGkuDTmWfzjHqDWEK5LLRP6oiOXe0JeI9mLHzL2nm6T3/ianaPEzeH7lpE/ciWDyqFUXoTZWeyK0xTjYxBSj9RJFoaoIxmXk6P8MJq+EvcS7ratByRUvWLaUFhcXhJ1iRK58BKcVPS0hxkzA77WB1UnrUfpkS1U/F5uYmYWGZ3Cz2fTvJHcsE228LUnnybaoIoDyY6BvZVUitmA+VhhTHoIKsREyCzC3VXq/HuwwuHdCdftzXJpXPoJSNzWAZH0oGnF+WE7m5Fqd36dqp2srL5bgFjFnyZzIkxdaU+ZW+Rm7aIbrb7nK2Pp9iequOBV6rnKeHZyc3hzG4lVVapoXl/U2cvfVgIqVtnuJE4XM4NuUdTALB

DeEgger Embedder隐写

在另一个隐藏文件中，DeEgger嵌入使您可以加密和隐藏在明显无恶意的机密文件。基本上应用程序二进制合并的第一个文件的第二个文件之一,无论其格式(jpg, png, .avi, mp3, mp4, pdf格式)。其他用户将无法告诉输出文件有一些隐藏在里面

1. 选择主机文件: 这里需要拖动到它的界面或使用指定的按钮加载，我们将要生成的假文件。 它可以是任何格式，例如简单的图像或 mp3。
2. 选择要嵌入的文件: 过程与上一点相同，不同的是这里我们将加载’秘密信息和*,* 也就是说，要隐藏的文件。
3. 结合: 单击此按钮，然后 假文件 这与我们在 主机文件. 常见和当前，对任何人都没有任何可疑之处，但对我们来说，这是一个只有发件人才能看到的带有小秘密的文件。

下载地址 http://deegger-embedder.findmysoft.com/download/

导出一堆base32，拿去解码出一堆没用的东西

以为是维吉尼亚就去试了一下，这到底是干嘛用的，到这就不会了来看wp，肯定是我太菜了

base32隐写

和base64隐写一样的，所以记录一下base64隐写

在对base64进行解码时，会将需要解码的字符串每四个分为一组（在有占位符=的情况下，待解码的内容长度总是4的倍数）
当末尾是=时，则将等于号去掉，并将最后一个字符的后两位二进制数去掉，剩下的二进制数长度即为8的倍数，再进行解码
当末尾是==时，则将两个等于号去掉，并将最后一个字符的后四位二进制数去掉，剩下的二进制数长度即8的倍数，再进行解码

在存在占位符=的情况下，会将部分位的二进制数丢弃，而这些被丢弃的位中可以插入隐写的信息，即在那些用0补充的位上插入别的信息，同时又不影响base解码
base64编码末尾=的个数只可能是0个、1个、2个，而0个的时候无法隐写，故我们需要考虑末尾有1个或2个等号的情况

import base64

def get_base32_diff_value(stego_line, normal_line):
    base32chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    for i in range(len(normal_line)):
        if stego_line[i] != normal_line[i]:
            return abs(base32chars.index(chr(stego_line[i]))-base32chars.index(chr(normal_line[i])))
    return 0

# base32 隐写解密
def base32stego_decode(lines):
    res = ''
    for i in lines:
        stego_line = i.strip()
        normal_line = base64.b32encode(base64.b32decode(i.strip()))
        diff = get_base32_diff_value(stego_line, normal_line)
        if '=' not in str(stego_line):
            continue
        if diff:
            res += bin(diff)[2:]
        else:
            res += '0'
    return res

with open(r"C:\Users\Administrator\Downloads\攻防世界\pyHAHA\Dream It Possible - extracted.txt", 'rb') as f:
    file_lines = f.readlines()
encrypt = open(r"C:\Users\Administrator\Downloads\攻防世界\pyHAHA\encrypt.txt",'w')
encrypt.write(base32stego_decode(file_lines))
encrypt.close()

from os import urandom

def generate(m, k):
    result = 0
    for i in bin(m ^ k)[2:]:
        result = result << 1
        if int(i):
            result = result ^ m ^ k
        if result >> 256:
            result = result ^ P
            continue
    return result

def convert(string):
    return int(string.encode('hex'), 16)

P = 0x10000000000000000000000000000000000000000000000000000000000000425L
flag1 = 'ThIs_Fl4g_Is_Ri9ht'
flag2 = 'Hey_Fl4g_Is_Not_HeRe'
encrypt1 = open('C:\Users\Administrator\Downloads\encrypt.txt', 'r').read()
encrypt2 = 0xec8d57d820ad8c586e4be0122b442c871a3d71cd8036c45083d860caf1793ddc
encrypt3 = 0xc40a0be335babcfbd8c47aa771f6a2ceca2c8638caa5924da58286d2a942697e
key3 = encrypt3 ^ convert(flag2)
key2 = encrypt2 ^ convert(flag1)
print('Found key2:',key2)
print('Found key3:',key3)

tmp = key3 - 233333333333L
for i in range(0,255):
    tmp = generate(tmp,0)
seed = tmp ^ key2
print 'Found seed:',seed
print 'use seed generate key3:',generate(key2,seed)+233333333333L

tmp = key2 - 233333333333L
for i in range(0,255):
    tmp = generate(tmp,0)
key1 = tmp ^ seed
print 'Found key1:',key1
print 'use key1 generate key2:',generate(key1,seed)+233333333333L

result = eval(hex(int(encrypt1,2))[:-1]) ^ eval('0x'+hex(key1)[2:-1]*22)
data = open('C:\Users\Administrator\Downloads\data.txt', 'w')
data.write(bin(result)[2:])
data.close()

from PIL import Image

str = open("C:\Users\Administrator\Downloads\data.txt", "r").read()
length = 240
width = 30
pic = Image.new("RGB", (length, width))
i = 0
for x in range(length):
    for y in range(width):
        if str[i] == '0':
            pic.putpixel([x, y], (0, 0, 0))
        else:
            pic.putpixel([x, y], (255, 255, 255))
        i += 1
pic.save("C:\Users\Administrator\Downloads\Flag.png")
# 这题难度才5分有没有搞错，这么套的题，一题顶5题不得10分

warmup

开始思路错了，仔细看给的图片和压缩包里的内容，发现都有一个共同的文件，那么下面就可以试试明文爆破了

解压出两张图像一样但大小差挺多的图片，肯定是藏东西了，猜测盲水印

传感器1

已知ID为0x8893CA58的温度传感器的未解码报文为：3EAAAAA56A69AA55A95995A569AA95565556 此时有另一个相同型号的传感器，其未解码报文为：3EAAAAA56A69AA556A965A5999596AA95656 请解出其ID

密码题？查了一下是差分曼切斯特编码

差分曼切斯特编码

https://www.cnblogs.com/BinB-W/p/5045918.html

import re 
hex1 = 'AAAAA56A69AA55A95995A569AA95565556'
def bintohex(s1):
    s2 = ''
    s1 = re.findall('.{4}',s1)
    print ('每一个hex分隔:',s1)
    for i in s1:
        s2 += str(hex(int(i,2))).replace('0x','')
    print ('ID:',s2)
 
def diffmqst(s):
    s1 = ''
    s = re.findall('.{2}',s)
    cc = '01'
    for i in s:
        if i == cc:
            s1 += '0'
        else:
            s1 += '1'
        cc = i  
    print ('差分曼切斯特解码:',s1)
    bintohex(s1)
 
#只能算曼切斯特编码,无法算差分
def mqst(s):  
    mdict = {'5': '00', '6': '01', '9': '10', 'A': '11'}
    a1 = ''.join(mdict[i] for i in s)
    a2 = ''.join(mdict[i][::-1] for i in s)
    print ('曼切斯特解码:   ',a1 )
    print ('曼切斯特解码2:  ',a2)
    bintohex(a1)
    bintohex(a2)
 
if __name__ == '__main__':
    bin1 = bin(int(hex1,16))[2:]
    diffmqst(bin1)
    # mqst(hex1)

得到 ID: 8024d8893ca584181，去掉前面5个后面4个就和题目给的传感器ID匹配，同理得到另一个传感器ID就是flag

MISCall

file看了一下是压缩包，直接7z提取出 .git，Git泄露了

git恢复

git  log
git  stash list
git  stash show
git  stash apply

拿到一个flag.txt，一个s.py，可以知道只需要运行这个py文件就行 NCN4dd992213ae6b76f27d7340f0dde1222888df4d3

Russian-zips

头部密码错误？也没提示要输入密码啊，010检查文件头有点问题

伪加密，把所有的 ushort deflags 由1 改成 0

ZIP伪加密的特征

zip 文件结构可以分为三个部分：压缩源文件数据区、压缩文件目录区、压缩源文件目录结束标志

压缩源文件数据区中的全局方式位标记是判断有无伪加密的重要标志，也就是压缩源文件数据区的第7、8两个字节09 00。
ZIP 的压缩源文件数据区全局方式位标记在010中显示的文件结构中为 ushort frFlags

压缩文件目录区的全局方式位标记是进行伪加密的关键，也就是压缩文件目录区的第9、10两个字节。
ZIP 的压缩文件目录区全局方式位标记在010中显示的文件结构中为 ushort deFlags

# 无加密的ZIP：
ushort frFlags应当为00 00 ,ushort deFlags应当为00 00
# 真加密的ZIP:
ushort frFlags应当为09 00 ,ushort deFlags应当为09 00
# 伪加密的ZIP:
ushort frFlags应当为00 00 ,ushort deFlags应当为09 00

# 总之 ushort frFlags 是判断真假加密的重要标志，ushort deFlags 的改动只是造成解压文件时一个密码的校验弹窗

拿到几个mca文件，搜了一下是什么，MC的模组地图

找个MC的地图编辑器来查看

Mc地图编辑

项目地址 https://github.com/Querz/mcaselector

Whisper

一个图片，一个exe，一个有密码的压缩包，应该是信息就在图片和exe中了，搜了下这三个人名发现是RSA算法的奠基人

binwalk分离，并且藏了一串base64

base64解码后再拿去binwalk检查一下，这里有个比较坑的地方就是开头的E不需要，这个地方卡半天，麻了

import base64
with open(r'C:\Users\Administrator\Downloads\攻防世界\Whisper\1.txt')as f:
    data = f.read()
f = open(r'C:\Users\Administrator\Downloads\攻防世界\Whisper\hint1','wb')
f.write(base64.b64decode(data))
f.close()

拿到一堆文本，猜测解压密码就在里面，直接找了

用这个密码就可以解压flag压缩包

提交成功以后去看了下官方的wp，怎么说呢，我也不懂逆向，其实那个exe文件中有提示hint2

Hint 2: a hidden RAR file, encoded in base64

the_golden_gate

硬件题，没接触过看不懂

官方wp https://github.com/ctfs/write-ups-2014/tree/master/seccon-ctf-2014/the-golden-gate

Get-the-key.txt

binwalk分离出一堆的key.txt，联想题目 get key，猜测flag在里面，所以直接找然后人傻了，还有藏假 flag的吗

看来不能直接找flag了，需要先找key.txt，原来就是第一个，还是个 gzip

qr-easy

这题挺有意思的，常见的图片隐写都检查了一下发现没什么特别的，因为这道题真的就是硬核修复二维码

29 * 29 ，纠错等级 H 1

qr码修复

参考文章

https://www.cnblogs.com/luogi/p/15469106.html

https://www.cnblogs.com/mq0036/p/14445719.html

https://coolshell.cn/articles/10590.html

wp https://yous.be/2014/12/07/seccon-ctf-2014-qr-easy-write-up/

data = '00100000' \
       '00110100' \
       '11111010' \
       '01000101' \
       '00010001' \
       '00111101' \
       '00000100' \
       '10011110' \
       '11010100' \
       '00010100' \
       '11011101' \
       '11010010' \
       '01010100' \
       '01001110' \
       '01011001' \
       '00001110' \
       '01010001' \
       '11011010' \
       '10010010' \
       '11010101' \
       '00011001' \
       '00010001' \
       '00001110' \
       '00010010' \
       '00011111' \
       '01000000'
alphanumeric = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:'.chars

def read(str, size)
  str.slice!(0, size)
end

def kanji(num)
  if num >= 0x1740
    (0xC140 + num / 0xC0 * 0x100 + num % 0xC0)
      .chr(Encoding::Shift_JIS).encode(Encoding::UTF_8)
  else
    (0x8140 + num / 0xC0 * 0x100 + num % 0xC0)
      .chr(Encoding::Shift_JIS).encode(Encoding::UTF_8)
  end
end

loop do
  case mode = read(data, 4)
  when '0010' # Alphanumeric
    count = read(data, 9).to_i(2)
    (count / 2).times do
      chunk = read(data, 11).to_i(2)
      print alphanumeric[chunk / 45] + alphanumeric[chunk % 45]
    end
    print alphanumeric[read(data, 11).to_i(2)] if count.odd?
  when '0100' # Byte
    count = read(data, 8).to_i(2)
    count.times do
      print read(data, 8).to_i(2).chr
    end
  when '1000' # Kanji
    count = read(data, 8).to_i(2)
    count.times do
      print kanji(read(data, 13).to_i(2))
    end
  when '0000' # Terminate
    break
  else
    fail "Unhandled mode #{mode}"
  end
end

原理大概懂了，这脚本再看看

Reverse-it

很显然数据是反的，题目也提示了，反回来就行，还需要镜像翻转一下，虽然直接看也能看出 flag是什么

import binascii
data = open(r'C:\Users\Administrator\Downloads\攻防世界\Reverse-it\a', 'rb').read()
data = binascii.hexlify(data)
with open(r'C:\Users\Administrator\Downloads\攻防世界\Reverse-it\flag.png', 'wb')as f:
    f.write(binascii.unhexlify(data[::-1]))

2-1

首先第一眼看到的就是png头被改了 8950

改回来png模板识别，然后报CRC的错，猜测是改了宽高，简单写个脚本计算CRC正确的宽高

import zlib
import struct

filename = r'C:\Users\Administrator\Downloads\攻防世界\2-1\148a3ba22b8541f48f354f3e27f0aa4c.png'
with open(filename, 'rb') as f:
    all_b = f.read()
    crc32key = int(all_b[29:33].hex(), 16)
    data = bytearray(all_b[12:29])
    n = 4095  
    for w in range(n):  # 高和宽一起爆破
        width = bytearray(struct.pack('>i', w))  
        for h in range(n):
            height = bytearray(struct.pack('>i', h))
            for x in range(4):
                data[x + 4] = width[x]
                data[x + 8] = height[x]
            crc32result = zlib.crc32(data)
            if crc32result == crc32key:
                print("宽为：", end="")
                print(width)
                print("高为：", end="")
                print(height)
                exit(0)
# 宽为：bytearray(b'\x00\x00\x02\xc5') ,高为：bytearray(b'\x00\x00\x02\xf8')

3-11

LSB 隐写，藏了压缩包

得到一串base64，拿去解码是png图片，这就是典型的base64转图片了，可以写脚本转图片，也可以直接在线base64转图片

FLAG{LSB_i5_SO_EASY}

7-2

给了一堆文件，看一眼内容都有啥

有点乱，也不像是16进制，再看文件名有点base的味道，试试连起来

这官方的wp也不知道在说啥，爱你的新装 提示了个锤子东西，不管了这个字符串是在最后一行发现的，所以东西也就藏在后面文件里

确实是找到了不一样的地方，按照wp的说法是键盘密码，我是真不知道他怎么来的

如果是16进制的话，他又有大于80的数，如果是10进制的话，他又有小于32的数，真的服了，直接看官方的wp解释

签到题

Z2dRQGdRMWZxaDBvaHRqcHRfc3d7Z2ZoZ3MjfQ==

base64
ggQ@gQ1fqh0ohtjpt_sw{gfhgs#}
栅栏密码 7
ggqht{ggQht_gsQ10jsf#@fopwh}
凯撒密码 14
ssctf{ssCtf_seC10ver#@rabit}

我们的秘密是绿色的

010打开直接报错

常见的隐写检查了一遍，什么都没发现，这种没提示的加密隐写真的恶心，谜语人是吧

Our Secret 文件隐写

可以将敏感信息隐藏于文件之中。软件的界面分成两个部分，一个部分用于隐藏数据，另一部分用于提取数据。你需要选择一个用于隐藏数据的载体文件，然后选择你需要隐藏的文件或数据，输入你的加密密码之后，软件会将数据隐藏于文件之中。

密码是绿色的部分 0405111218192526

提取出来 try.zip，又是密码。套娃爆破密码了，19950822

真就套娃，try.zip里拿到flag.zip和readme.txt，flag.zip里又是flag.zip和readme.txt，猜到了是明文攻击，看CRC也知道readme.txt一样的

qddpqwnpcplen%prqwn_{_zz*d@gq}
栅栏密码 6
qwlr{ddneq_@dpnwzgpc%nzqqpp_*}
凯撒密码 11
flag{ssctf_@seclover%coffee_*}

baby_enc

密码题？反过来写解密 in.txt就行，加密方式是5次相邻异或

import codecs
def enc(s, t):
	if t:
		l = list(map(ord, s))
		return enc(''.join(list(map(chr, [l[i]^l[i+1] for i in range(len(l)-1)]))), t-1)
	else:
		return s
with open('in.txt') as f:
	s = enc(f.read(), 5)
with open('out.txt', 'w') as f:
	f.write(s)

写反向解密不会，直接放的官方的，大概意思就是知道flag前缀是 RCTF{，然后去遍历每种异或可能

tmp = ""
with open(r'C:\Users\Administrator\Downloads\攻防世界\baby_enc\out.txt', 'r') as f:
    tmp = f.read()
test = list(map(ord, tmp))
for i in range(len(test) - 5):
    lis = list(map(ord, "RCTF{"))
    tmpi = i
    for j in range(len(test) - 5 - i):
        tmp = lis[j] ^ lis[j + 1] ^ lis[j + 4] ^ test[tmpi]
        tmpi += 1
        if chr(tmp) == "}":
            lis.append(tmp)
            print(str(i) + " results:" + ''.join(map(chr, lis)))
            break
        elif chr(tmp) == "\n":
            break
        elif tmp < 43:
            break
        else:
            lis.append(tmp)
# RCTF{te1l_mE_tHe_wAy_you_so1ve_thIs}

intoU

频谱图，拉到最后面就可以看见

message

7fffffffffffffffffffffffffffffffbffff0e10419dff07fdc3ffdaeab6deffdbfff6ffed7f7aef3febfffb7ff1bfbc675931e33c79fadfdebbae7aeddedb7dafef7dc37df7ef6dbed777beedbedb77b6de24718f260e0e71879fffffffffffffffffffffffffffffffffffffffffff07f87fc7f9ffffffffdbfbbfdbfeffffffffebfdffdfff7ffffff871c33e6fe7bffffffd5aefeed62dcffffffeadf9fb8bb0efffffff56df5db6dbf7ffffffaa0c21e19e3bffffe07ffffffffff9fffffffffffffffffffffffffffffffffffffff

转ascii是乱码，转2进制
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111011111111111111111100001110000100000100000110011101111111110000011111111101110000111111111111011010111010101011011011011110111111111101101111111111111101101111111111101101011111110111101011101111001111111110101111111111111110110111111111110001101111111011110001100111010110010011000111100011001111000111100111111010110111111101111010111011101011100111101011101101110111101101101101111101101011111110111101111101110000110111110111110111111011110110110110111110110101110111011110111110111011011011111011011011011101111011011011011110001001000111000110001111001001100000111000001110011100011000011110011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000001111111100001111111110001111111100111111111111111111111111111111111110110111111101110111111110110111111111011111111111111111111111111111111111010111111110111111111110111111111111101111111111111111111111111111000011100011100001100111110011011111110011110111111111111111111111111111101010110101110111111101110110101100010110111001111111111111111111111111110101011011111100111111011100010111011000011101111111111111111111111111111010101101101111101011101101101101101101111110111111111111111111111111111101010100000110000100001111000011001111000111011111111111111111111100000011111111111111111111111111111111111111111111001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
长度1679，因数分解也就是 73 * 23,所以试试画图有没有用

import numpy as np
from matplotlib import pyplot as plt
with open(r'C:\Users\Administrator\Downloads\攻防世界\message\msg.txt')as f:
    src = f.read()
bins = bin(int(src, 16))[2:]
# print(len(bins))  1679
# 73 * 23
x = np.array(list(bins), dtype=np.uint8)
# plt.imshow(x.reshape(23, 73))
plt.imsave(r'C:\Users\Administrator\Downloads\攻防世界\message\flag.png', x.reshape(23, 73))

mysql

给了个数据库的数据文件，可能是想要恢复数据库然后在里面找flag吧，没必要这样做

数据库文件里的东西无非就是一些建表建库插值这些操作的SQL语句和一些数据，这些东西都是明文，直接找flag就行

互相伤害!!!

010查看是wireshark提取的流量包，没多少流量，直接追踪tcp流挨个看过去

22个流全是图片，全导出来

扫二维码发现是AES，猜测密码就是他旁边的 CTF

解密 668b13e0b0fc0944daf4c223b9831e49

提交flag错误，16进制解码是乱码，估计那堆图片还没完，全部再检查一遍，发现后面都藏了zip

随便提取一个出来看看，又是一个二维码

提示要提取那张内裤的表情，确实，提取出了压缩包要密码，密码就是开始的AES解密出的那个

扫中间的那个小的得到flag flag{97d1-0867-2dc1-8926-144c-bc8a-4d4a-3758}

LooL

base64转图片保存

6fb53295b535ebdffa1ac8843fc6acdd 32位，16进制转字符串是乱码，猜MD5

直接搜 brainloller 知道了是brainfuck 的 brainloller 模式，bftools 就可以提取

bftools

flag youdidwell

traffic1

流量协议看了一下，大部分是TCP的流量，其中部分是HTTPS的流量，所以猜肯定是要找ssl解开https了

追踪tcp流，流也不多，86个，HTTPS的直接不看

提取出来有密码，010检查，不知道密码先放着爆破，继续看流量

又找到一个，这个是伪加密，上一个不是伪加密，可能是真加密了



找到 sslkey.log

wireshark导入sslkey.log 解密HTTPS流量

可以发现现在多了很多的http的流量，这就是sslkey 起作用了，之前都是隐藏的

大概就是向百度网盘请求东西，然后发现这里下载了一个压缩包，导出来看看

导出来是段音频，日文歌听不懂，直接拉到最后发现 key ,用这个去解压最开始的那个真加密的flag.zip，得到flag

hit-the-core

cvqAeqacLtqazEigwiXobxrCrtuiTzahfFreqc{bnjrKwgk83kgd43j85ePgb_e_rwqr7fvbmHjklo3tews_hmkogooyf0vbnk0ii87Drfgh_n kiwutfb0ghk9ro987k5tfb_hjiouo087ptfcv}

看着就像flag，注意前面的XCTF，每个大写字母中间隔了4个小写

src = "cvqAeqacLtqazEigwiXobxrCrtuiTzahfFreqc{bnjrKwgk83kgd43j85ePgb_e_rwqr7fvbmHjklo3tews_hmkogooyf0vbnk0ii87Drfgh_n kiwutfb0ghk9ro987k5tfb_hjiouo087ptfcv}"
flag = ""
for i in range(3,len(src),5):
    flag += src[i]
print(flag)
# ALEXCTF{K33P_7H3_g00D_w0rk_up}

Just-No-One

给了个软件安装的exe，需要密码？

丢到010没发现什么，难道是逆向题？又仔细找

YOU MAY SUBMIT THIS TO GET TEN POINTS: ILOVEREADINGEULAS

想不到是真想不到，提交这个就是flag，那后面的密码验证是什么意思，这题考点在哪

ext3