ImaginaryCTF2022

​ 刚好看到就做了下题，真的感叹国外赛事的高质量，每次都能学点东西。比赛地址：https://2022.imaginaryctf.org/Challenges

Web

button

页面看起来是空白的，审计前端代码，发现有非常多的白色小按钮(所以看不见)，在源码搜索ctf可以找到嵌入式js代码，可以发现有几个button对应执行的是motSusfunclion()，所以我们只要去控制台输入此函数就能弹出flag：ictf{y0u_f0und_7h3_f1ag!}

rooCookie

根据题目描述，出题人把密码藏在了cookie里，审计会看到cookie以及生成cookie的js代码，于是把算法逆一下就可以恢复password，即flag。

1
2
3
4
5
6
7
function createToken(text) {
	let encrypted = "";
  for (let i = 0; i < text.length; i++) {
		encrypted += ((text[i].charCodeAt(0)-43+1337) >> 0).toString(2)
  }
  document.cookie = encrypted
}
1
2
3
4
5
6
7
8
9
10
11
cookie = '101100000111011000000110101110011101100000001010111110010101101111101011110111010111001110101001011101001100001011000000010101111101101011111011010011000010100101110101001101001010010111010101111110101011011111011000000110110000001101100001011010111110110110000000101011100101010100101110100110000101011101111010111000110110000010101011101001011000100110101110110101001111101010111111010101000001101011011011010100010110101110110101011011111010100010110101101101101100001011010110111110101000011101011111001010100010110101101101101100000101010011111010100111110101011011011010111000010101000010101011100101011000101110100110000'
print(bin(1337))#可以确定每个字符对应11位01序列的密文
print(len(cookie))
for i in range(0,627,11): 
    #print(i)
    s = int(cookie[i:i+11],2)
    #print(s)
    m = s - 1337 + 43
   # print(m)
    print(chr(m),end='')
# username="roo" & password="ictf{h0p3_7ha7_wa5n7_t00_b4d}"

SSTI Golf

这种白盒ssti应该算是最简单的，也没什么过滤，基本就只有payload长度限制；首先看一下源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python3

from flask import Flask, render_template_string, request, Response

app = Flask(__name__)

@app.route('/')
def index():
    return Response(open(__file__).read(), mimetype='text/plain')

@app.route('/ssti')
def ssti():
    query = request.args['query'] if 'query' in request.args else '...'
    if len(query) > 48:
        return "Too long!"
    return render_template_string(query)

app.run('0.0.0.0', 1337)

试一下模板解析，可以成功：

所以接下来尝试执行命令，首先用config看看全局变量，发现有os，那么可以利用lipsum访问os进行命令执行（popen有回显）

1
lipsum  flask的一个方法，可以用于得到__builtins__，而且lipsum.__globals__含有os模块：{{lipsum.__globals__['os'].popen('ls').read()}}

这是payload：


其实这题还有其他利用方法，我们可以用脚本去遍历一下object的子类，利用其他子类的特性进行rce，作为拓展，给出链接：
http://www.hackdig.com/06/hack-677892.htm
https://blog.csdn.net/zbbjya/article/details/124185476

Misc

Sponsors

给了赞助商的主页，访问其中一个，有个视频，视频的结尾处有flag。

pyprison

python沙盒逃逸，以前经常遇到但不会做，这次的比较简单，学习了一下。
首先是给了我们python jail的源码：

1
2
3
4
5
6
#!/usr/bin/env python3

while True:
  a = input(">>> ")
  assert all(n in "()abcdefghijklmnopqrstuvwxyz" for n in a)
  exec(a)

服务器会过滤除了字母和()之外的所有符号，其余的部分用exec当作命令执行，在操作之前，先了解一下python动态加载模块。逃逸过程分析：
1.eval(input())
这里绕过了过滤，并且可以把我们输入的字符当作命令执行，这里之所以要加上eval，是因为出题人故意用的exec，它是无回显的，所以我们才需要自己加一层eval(有回显)，或者用print(exec())
2.—import—(‘os’).system(‘ls’)
这里不多说了，动态加载os模块rce
两种利用方法：

Crypto

emojis

序列有两种符号，分别转成0和1，再转成字符串即可：ictf{enc0ding_is_n0t_encrypti0n_1b2e0d43}

smoll

1
2
3
4
5
6
7
8
9
10
11
from Crypto.Util.number import *
from gmpy2 import *
# factor分解n
p = 1314503602874176261160006408736468830398552989268751172636991566212261500942084902638924872933455766527167138778836649666000256787470232570894174402457567851267
n = 13499674168194561466922316170242276798504319181439855249990301432638272860625833163910240845751072537454409673251895471438416265237739552031051231793428184850123919306354002012853393046964765903473183152496753902632017353507140401241943223024609065186313736615344552390240803401818454235028841174032276853980750514304794215328089
q = n//p
phi = (p-1)*(q-1)
e = 65537
d = invert(e,phi)
c = 12788784649128212003443801911238808677531529190358823987334139319133754409389076097878414688640165839022887582926546173865855012998136944892452542475239921395969959310532820340139252675765294080402729272319702232876148895288145134547288146650876233255475567026292174825779608187676620580631055656699361300542021447857973327523254
print(long_to_bytes(pow(c,d,n)))

huge

n由很多个不大的素数相乘，多因子，高次数n求phi即可。

1
2
3
4
5
6
7
8
9
from Crypto.Util.number import *
from gmpy2 import *

phi = 521*520 * 540 * 562 * 569*568 * 570 * 577*576 * 587*586 * 598 * 601**2*600 * 606 * 612 * 617**2*616 * 619*618 * 630 * 647**2*646 * 659**2*658 * 660 * 673*672 * 677**2*676 * 682 * 691**3*690 * 701**3*700 * 709*708 * 718 * 738 * 742 * 760 * 769*768 * 797**5*796 * 809**3*808 * 810 * 820 * 827**3*826 * 828 * 839*838 * 852 * 856 * 859*858 * 863*862 * 877*876 * 880 * 882 * 886 * 910 * 918 * 937*936 * 947**4*946 * 967*966 * 970 * 977*976 * 982 * 991**2*990 * 996 * 1009**2*1008 * 1012 * 1019**2*1018 * 1020
e = 65537
c= 194667317703687479298989188290833629421904543231503224641743768867721632949682167895699280370759100055314992068135383846690184090232092994595979623784341194946153538127175310278245722299688212621004144260665233469561373125699948009903943019071999887294005117156960295183926108287198987970959145603429337056005819069
d = invert(e,phi)
n = 257827703087398016057355158654193468564980243813004452658087616586210487667215030370871398983230710387803731676134007721137156696714627083072326445637415561591372586919746606752675050732692230618293581354674196658443898625965651230501721590806987488038754683843111434873697465691139129703835890867256688046172118591
print(long_to_bytes(pow(c,d,n)))

cbc

自己实现了不安全的cbc分组模式，直接把前一组的密文当作key给下一组加密，相当于知道key了，第一组分组解不出来没关系，题目加密的是flag*3。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from os import urandom

ct = b"\xa2\xb8 <\xf2\x85\xa3-\xd1\x1aM}\xa9\xfd4\xfag<p\x0e\xb7|\xeb\x05\xcbc\xc3\x1e\xc3\xefT\x80\xd3\xa4 ~$\xceXb\x9a\x04\xf0\xc6\xb6\xd6\x1c\x95\xd1(O\xcfx\xf2z_\xc3\x87\xa6\xe9\x00\x1d\x9f\xa7\x0bm\xca\xea\x1e\x95T[Q\x80\x07we\x96)t\xdd\xa9A 7dZ\x9d\xfc\xdbA\x14\xda9\xf3\xeag\xe3\x1a\xc8\xad\x1cnL\x91\xf6\x83'\xaa\xaf\xf3i\xc0t=\xcd\x02K\x81\xb6\xfa.@\xde\xf5\xaf\xa3\xf1\xe3\xb4?\xf9,\xb2:i\x13x\xea1\xa0\xc1\xb9\x84"
c = [ct[i:i+16] for i in range(0, len(ct), 16)]
key = urandom(16)
flag = b''
for block in c:

    cipher = AES.new(key, AES.MODE_ECB)
    next = cipher.decrypt(block)
    flag=flag+next
    key = block
print(flag)

Secure Encoding: Hex

这题以前没做过类似的，重点记一下；题目是把16进制的字符表置换了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python3

from random import shuffle

charset = '0123456789abcdef'
shuffled = [i for i in charset]
shuffle(shuffled)

d = {charset[i]:v for(i,v)in enumerate(shuffled)}

pt = open("flag.txt").read()
assert all(ord(i)<128 for i in pt)

ct = ''.join(d[i] for i in pt.encode().hex())
f = open('out.txt', 'w')
f.write(ct)
# 0d0b18001e060d090d1802131dcf011302080ccf0c070b0f080d0701cf00181116

由排列组合的知识可知一共有16!种置换方案，这很大无法直接爆破。但观察到把ictf{和}转成16进制和密文的hex的字符频率一致，猜测前后格式就是ictf{}；那么根据这一部分明文密文对照可以得到置换群的部分映射关系，剩下的爆破即可，剩下需要爆破a96种组合，过滤一下字符得到最终flag。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import itertools
import binascii
import string

chars = string.ascii_letters+string.digits+'!'+'-'+'_'
s = '0d0b18001e060d090d1802131dcf011302080ccf0c070b0f080d0701cf00181116'
know1 = '696374667b'
know2 = '7d'
dic = {}
for i in range(10):
    dic.update({s[i]:know1[i]})
dic.update({'1':'7'})
dic.update({'6':'d'})
print(len(dic))
print(dic)

ss = '0db18e6923cf7'
# 看看哪些是未知的映射，需要爆破
for i in ss:
    if i not in dic.keys():
        print(i,end='')
print()

table = '0123456789abcdef'
for i in table:
    if i not in dic.values():
        print(i,end='')

t = '01258acef'
tt = '923cf7'

for i in itertools.permutations(t,6):
    dic1 = dic
    for j in range(6):
        dic1.update({tt[j]:i[j]})
    mm = ''
    for m in s:
        mm = mm + dic[m]
    flag = binascii.unhexlify(mm)
    if b'encoding' in flag:
        print(flag)
# ictf{military_grade_encoding_ftw}

Lorge

p-1光滑，但因子不超过25bit这一限制导致因子还是可能较大；Pollard’s p − 1 算法可以做但是需要改进一下。
这是通常的算法写法：

1
2
3
4
5
6
7
8
9
10
11
def Pollards_p_1(N):
    a = 2
    n = 2
    while True:
        a = pow(a, n, N)
        res = gcd(a - 1, N)
        if res != 1 and res != N:
            print('n =', n)
            print('p =', res)
            return res
        n += 1

算法这样写是为了保证质数因子次数大于1的时候也能分解出来，并且每次对n加1都进行一次gcd判定，当素因子比特稍微大点效率就很低，所以普通的写法无法做出本题。想一想如何优化？
1.减少gcd判定 2.改变每次n加1的流程
减少gcd判定很好理解，只要前边依次乘了素数，隔一段时间进行一次判定即可；而n每次加1是因为可能出现质数因子次数大于1的情况，由于这题的特殊性可以大胆猜想因子次数都是1，否则几乎无法优化。综上所述可以做出优化如下：
1.由于比特最大为25，所以可以把这个范围内的质数先全部找到，遍历的时候只需要按索引取值，python库找素数的算法肯定比我们自己后续遍历的时候取素数效率高。
2.先把大部分素数乘起来，这个过程不去gcd判定，以节约时间(猜想出题人肯定会放几个大素数进去的)；在乘最后一部分大素数的时候n每增加1000左右做一次判定。
最后的exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from Crypto.Util.number import *
from libnum import primes
from tqdm import tqdm

P=primes(2**25)
print('ok')

def Pollard_p_1(N):
    a = 2
    while True:
        f = a
        for n in tqdm(range(1, 2**19)):
            f = pow(f, P[n], N)
        for n in tqdm(range(2**19, len(P))):
            f = pow(f, P[n], N)
            if n % 1000 == 0:
                d = GCD(f-1, N)
                if 1 < d < N:
                    return d
        print(a)
        a += 1

N=63038895359658613740840475285214364620931775593017844102959979092033246293689886425959090682918827974981982265129797739561818809641574878138225207990868931316825055004052189441093747106855659893695637218915533940578672431813317992655224496134300271524374912502175195904393797412770270676558054466831561609036199966477
print(Pollard_p_1(N))
p=145032322033866860846381416443898168813760964460593559495755044148135716181467611533887294886701334975636615688439165591336904142171600066773005252254144288439
e=0x10001
ct = 60515029337308681079476677877525631415600527185785323978384495461916047877351538207473264679842349366162035496831534576192102896080638477601954951097077261305183669746007206897469286005836283690807247174941785091487066018014838515240575628587875110061769222088950451112650700101446260617299040589650363814995825303369
q=N//p
phi=(p-1)*(q-1)
d=inverse(e,phi)
m=pow(ct,d,N)
print(long_to_bytes(m))
# b'ictf{why_d1d_sm0ll_3v3n_sh0w_up_on_f4ct0rdb???_That_m4d3_m3_sad!}'

四五分钟能跑出结果。

hash

这道题hash师傅用矩阵解的，我不太能理解，于是找到了暴力破解的办法；因为password长度在15-20，分布区间很小，所以考虑遍历，用z3求解，一是因为z3对于xor求解运算很快，二是由于password是string.printable，所以限制条件足以得到正确解。exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
from pwn import *
from z3 import *

config = [
    [int(a) for a in n.strip()] for n in open("jbox.txt").readlines()
]  # sbox pbox jack in the box
def sha42(s: bytes, rounds=42):
    out = [0] * 21
    for round in range(rounds):
        for c in range(len(s)):
            if config[((c // 21) + round) % len(config)][c % 21] == 1:
                out[(c + round) % 21] ^= s[c]
    return out

def solve_preimage(h):
    for l in range(15,21):
        inp = [BitVec(f"inp_{i}", 8) for i in range(l)]
        sol = Solver()
        for x in inp:
            sol.add(x != 0, x != 0x10, x != 0x11 ,x < 0x7F) #这里用密码为printable限制一下即可
        for x, y in zip(h, sha42(inp)):
            sol.add(x == y)
        if sol.check() != sat:
            continue
        m = sol.model()
        return bytes([m[x].as_long() for x in inp])

# io = process(['python', 'hash.py'])
io = remote("34.90.15.213", 1337)
for i in range(50):
    io.recvuntil(b'sha42(password) = ')
    h = bytes.fromhex(io.recvlineS().strip())
    password = solve_preimage(h)
    print(i, f'sha42({password.hex()}) = {h.hex()}')
    io.sendlineafter(b'hex(password) = ',password.hex().encode())
io.interactive()
# Congrats! Your flag is: ictf{pls_d0nt_r0ll_y0ur_0wn_hashes_109b14d1}

otp

这题出的挺好，考查选手用数理统计的知识解决密码学问题；出题人生成了一个jumbler列表，然后利用jumbler实现了一个看似随机的序列生成器；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def secureRand(bits, seed):
  jumbler = []
  jumbler.extend([2**n for n in range(300)])
  jumbler.extend([3**n for n in range(300)])
  jumbler.extend([4**n for n in range(300)])
  jumbler.extend([5**n for n in range(300)])
  jumbler.extend([6**n for n in range(300)])
  jumbler.extend([7**n for n in range(300)])
  jumbler.extend([8**n for n in range(300)])
  jumbler.extend([9**n for n in range(300)])
  out = ""
  state = seed % len(jumbler)
  for _ in range(bits):
    if int(str(jumbler[state])[0]) < 5:
      out += "1"
    else:
      out += "0"
    state = int("".join([str(jumbler[random.randint(0, len(jumbler)-1)])[0] for n in range(len(str(len(jumbler)))-1)]))
  return long_to_bytes(int(out, 2)).rjust(bits//8, b'\0')

这样的白盒生成器让我们有机会去直接对0和1的生成结果进行统计，可以发现每次生成1和0的概率大约为2：1；因为加密过程就是简单的异或操作，所以只要是0，明文和密文该位不变，若为1，则该位取反；因此加密有大概70%的概率是把该位翻转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
jumbler = []
jumbler.extend([2 ** n for n in range(300)])
jumbler.extend([3 ** n for n in range(300)])
jumbler.extend([4 ** n for n in range(300)])
jumbler.extend([5 ** n for n in range(300)])
jumbler.extend([6 ** n for n in range(300)])
jumbler.extend([7 ** n for n in range(300)])
jumbler.extend([8 ** n for n in range(300)])
jumbler.extend([9 ** n for n in range(300)])

count = 0
for i in jumbler:
    if int(str(i)[0]) < 5:
        count += 1
print(count,len(jumbler)-count)
# 1677 723

因此我们可以多次请求flag的密文，得到多组密文；统计各组密文每一位的0和1个数比例，方法是把各组对应位的数字(1 or 0)加起来，与组数的0.5倍进行比较，看该位1和0哪个更多；cipher中某一位0出现多说明其原本为1，1出现的多则原本为0。exp参考大佬的，很简洁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *
import numpy as np
from tqdm import tqdm

io = remote("otp.chal.imaginaryctf.org", 1337)
T = 200 # 组数越多越精确但越慢
cts = []
for _ in tqdm(range(T)):
    io.sendlineafter(b"Enter plaintext: ", b"FLAG")
    io.recvuntil(b"Encrypted flag: ")
    ct = bytes.fromhex(io.recvlineS().strip())
    cts.append(bits(ct))

print(unbits((np.array(cts).T.sum(axis=1) < T * 0.5) * 1))
# ictf{benfords_law_catching_tax_fraud_since_1938}

扫一扫，分享到微信

微信分享二维码
本站总访问量： 总访客次数：

tag:

梦想是成为全栈佬并养一只猫