首页课程文章
无痕注入APC注入线程注入读写驱动注入技术句柄表进程线程系统调用保护模式内存管理远程CALL软件调试驱动封装云下发驱动开发FPS数据方框透视FPS方框FPS自瞄CED3DHOOKD3D绘制Imgui绘制DWM
内核课程驱动出租学习路线聊天室免责声明提问技巧

CTF对抗-HKCERT CTF 部分Re题解

推荐 原创

周杰伦

文章分类CTF对抗阅读数 : 243阅读时长 : 9分钟


【CTF对抗-HKCERT CTF 部分Re题解】此文章归类为：CTF对抗。

HKCERT CTF 部分Re题解

闲来无事，勾栏解题，看了看香港的这个网安夺旗赛，感觉题目质量都挺高的，写一个博客记录一下我做的几题

Morph

file
IDA分析报错，需要首先查看具体什么原因
file
decompress是异或，其实从compress这个词我们就知道应该是对数据做一些处理了，处理的数据正好就是传参的verify函数
file
看到verify函数我们会发现有很多，所以一个个手动解混淆花费的时间有点多，根据decompress的传参我们可以发现每一个verify的字节大小都是86，但是每一个verify的传参不一致，但是写脚本获取传参过于麻烦，发现参数都在-128-128之间，正确的话前四个字节必然是F3 0F 1E FA，直接梭就完事了，就不需要读取decompress传入的参数了。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import re
import idautils
import idaapi
import idc
 
def find_specific_verify_exports():
    """
    查找导出表中名称以 _Z8verify_ 或 _Z9verify_ 开头且后面接一个数字的函数，并返回其名称和地址。
    """
    verify_exports = []
    pattern = re.compile(r"^_Z(?:8|9)verify_(\d+)")  # 匹配 _Z8verify_ 或 _Z9verify_ 后接数字的格式
 
    for i in range(idaapi.get_entry_qty()):
        ordinal = idaapi.get_entry_ordinal(i)
        func_name = idaapi.get_entry_name(ordinal)
 
        # 检查函数名是否符合指定格式
        if func_name and pattern.match(func_name):
            func_addr = idaapi.get_entry(ordinal)
            verify_exports.append((func_name, func_addr))
 
    return verify_exports
 
def xor_bytes(data, key):
    """将给定数据中的每个字节与指定的key进行异或"""
    return bytes([b ^ key for b in data])
 
def patch_memory(address, xor_key):
    """直接对内存中的数据进行补丁"""
    original_data = idc.get_bytes(address, 86)  # 读取从 address 到 address+85 的字节
    if not original_data:
        print(f"无法读取地址 {hex(address)} 的数据")
        return False
     
    # 对数据进行异或
    patched_data = xor_bytes(original_data, xor_key)
     
    # 写入补丁数据到内存中
    for offset, byte in enumerate(patched_data):
        idc.patch_byte(address + offset, byte)
     
    print(f"已在内存中补丁地址范围 {hex(address)} 到 {hex(address+85)}，使用异或键 {xor_key}")
    return True
 
def process_address_range(address):
    """处理给定地址，尝试找到满足条件的异或数字并应用补丁"""
    original_data = idc.get_bytes(address, 86)  # 读取从 address 到 address+85 的字节
    if not original_data:
        print(f"无法读取地址 {hex(address)} 的数据")
        return None
     
    for xor_key in range(-255, 256):
        xor_key &= 0xFF  # 保证异或键值在 0 到 255 的范围内
        # 取地址到地址+3的数据并与当前 xor_key 异或
        test_data = xor_bytes(original_data[:4], xor_key)
         
        # 检查异或后的前四个字节是否等于 F3 0F 1E FA
        if test_data == b'\xF3\x0F\x1E\xFA':
            # 满足条件时，直接补丁内存
            if patch_memory(address, xor_key):
                print(f"成功对地址 {hex(address)} 应用补丁，异或键为 {xor_key}")
            return xor_key
 
    print(f"地址 {hex(address)} 没有找到满足条件的异或键")
    return None
 
# 获取符合条件的地址列表并进行补丁
filtered_exports = find_specific_verify_exports()
if filtered_exports:
    print("开始处理符合条件的 'verify' 函数地址...")
    for func_name, func_addr in filtered_exports:
        print(f"Processing function: {func_name} at Address: {hex(func_addr)}")
        process_address_range(func_addr)
else:
    print("No specific 'verify' functions found in export table.")

IDApython直接识别开始爆破，修复后可能IDA还识别不过来，这个时候可以保存好patch后的附件，或者跑下面的IDApython代码重新识别

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
import re
import idautils
import idaapi
import idc
 
# 步骤2：删除所有现有的函数定义
print("Starting to undefine all existing functions...")
for func_ea in idautils.Functions():
    func_name = idc.get_func_name(func_ea)
    print(f"Undefining function {func_name} at {hex(func_ea)}")
    idc.del_func(func_ea)  # 删除函数定义
 
print("All functions have been undefined.")
 
# 步骤3：将所有代码区域设置为未定义状态，但跳过数据段
print("Setting all instructions and data to undefined in code segments...")
for seg_ea in idautils.Segments():
    # 跳过数据段，仅处理代码段
    if idc.get_segm_attr(seg_ea, idc.SEGATTR_TYPE) != idc.SEG_CODE:
        print(f"Skipping data segment at {hex(seg_ea)}")
        continue
 
    start = seg_ea
    end = idc.get_segm_end(seg_ea)
     
    # 遍历段中的每个地址，并将其设置为未定义
    for head in idautils.Heads(start, end):
        idc.del_items(head, idc.DELIT_SIMPLE)  # 将所有指令和数据设置为未定义
 
print("All code in code segments set to undefined.")
 
# 步骤4：重新标记整个程序的代码段以进行重新分析
print("Marking all code segments for reanalysis...")
for seg_ea in idautils.Segments():
    if idc.get_segm_attr(seg_ea, idc.SEGATTR_TYPE) == idc.SEG_CODE:
        ida_auto.auto_mark_range(seg_ea, idc.get_segm_end(seg_ea), ida_auto.AU_CODE)
 
ida_auto.auto_wait()  # 等待重新分析完成
 
print("Reanalyzed all code segments, excluding data segments.")

file

弄好之后小时的代码都回来了
file
每一次都是前后两个位置的异或等于一个值，继续搓脚本输出他，把每一位结果记录下来，构建约束关系，然后z3梭哈
file

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import re
import idaapi
import idautils
import idc
 
def find_specific_verify_exports():
    """
    查找导出表中名称以 _Z8verify_ 或 _Z9verify_ 开头且后面接一个数字的函数，并返回其名称和地址。
    """
    verify_exports = []
    pattern = re.compile(r"^_Z(?:8|9)verify_(\d+)")  # 匹配 _Z8verify_ 或 _Z9verify_ 后接数字的格式
 
    for i in range(idaapi.get_entry_qty()):
        ordinal = idaapi.get_entry_ordinal(i)
        func_name = idaapi.get_entry_name(ordinal)
 
        # 检查函数名是否符合指定格式
        if func_name and pattern.match(func_name):
            func_addr = idaapi.get_entry(ordinal)
            verify_exports.append((func_name, func_addr))
 
    return verify_exports
 
def extract_equation_from_verify(func_addr):
    """
    从每个 verify 函数中提取 mov esi 和 cmp al 指令来生成方程。
    """
    esi_values = []
    cmp_value = None
 
    # 遍历函数指令，直到找到目标指令或到达函数结束
    for instr_addr in idautils.FuncItems(func_addr):
        mnemonic = idc.print_insn_mnem(instr_addr)
         
        # 查找 mov esi, <imm> 指令
        if mnemonic == "mov" and "esi" in idc.print_operand(instr_addr, 0):
            esi_value = idc.get_operand_value(instr_addr, 1)
            esi_values.append(esi_value)
         
        # 查找 cmp al, <imm> 指令
        elif mnemonic == "cmp" and "al" in idc.print_operand(instr_addr, 0):
            cmp_value = idc.get_operand_value(instr_addr, 1)
         
        # 当找到两个 esi 值和一个 cmp 值时，可以生成方程
        if len(esi_values) == 2 and cmp_value is not None:
            break
 
    # 确保收集到所有所需的值
    if len(esi_values) == 2 and cmp_value is not None:
        equation = f"input[0x{esi_values[0]:X}] ^ input[0x{esi_values[1]:X}] == 0x{cmp_value:X}"
        return equation
    else:
        return None
 
# 主函数，获取所有符合条件的 verify 函数并提取方程
filtered_exports = find_specific_verify_exports()
if filtered_exports:
    print("生成 verify 函数的方程:")
    for func_name, func_addr in filtered_exports:
        equation = extract_equation_from_verify(func_addr)
        if equation:
            print(f"{func_name}: {equation}")
        else:
            print(f"{func_name}: 无法生成方程")
else:
    print("未找到符合条件的 'verify' 函数")

file

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
from z3 import *
 
# 创建 0x37（55）个字节的输入变量（假设从 input[0] 到 input[0x36]）
input_vars = [BitVec(f'input_{i}', 8) for i in range(0x37)]
 
# 初始化 Z3 Solver
solver = Solver()
 
# 添加方程到 solver
constraints = [
    input_vars[0x0] ^ input_vars[0x1] == 0x3,
    input_vars[0x1] ^ input_vars[0x2] == 0x8,
    input_vars[0x2] ^ input_vars[0x3] == 0x6,
    input_vars[0x3] ^ input_vars[0x4] == 0x17,
    input_vars[0x4] ^ input_vars[0x5] == 0x6,
    input_vars[0x5] ^ input_vars[0x6] == 0x46,
    input_vars[0x6] ^ input_vars[0x7] == 0x6,
    input_vars[0x7] ^ input_vars[0x8] == 0x4F,
    input_vars[0x8] ^ input_vars[0x9] == 0x8,
    input_vars[0x9] ^ input_vars[0xA] == 0x40,
    input_vars[0xA] ^ input_vars[0xB] == 0x5F,
    input_vars[0xB] ^ input_vars[0xC] == 0xA,
    input_vars[0xC] ^ input_vars[0xD] == 0x39,
    input_vars[0xD] ^ input_vars[0xE] == 0x32,
    input_vars[0xE] ^ input_vars[0xF] == 0x5D,
    input_vars[0xF] ^ input_vars[0x10] == 0x54,
    input_vars[0x10] ^ input_vars[0x11] == 0x55,
    input_vars[0x11] ^ input_vars[0x12] == 0x57,
    input_vars[0x12] ^ input_vars[0x13] == 0x1F,
    input_vars[0x13] ^ input_vars[0x14] == 0x48,
    input_vars[0x14] ^ input_vars[0x15] == 0x5F,
    input_vars[0x15] ^ input_vars[0x16] == 0x9,
    input_vars[0x16] ^ input_vars[0x17] == 0x38,
    input_vars[0x17] ^ input_vars[0x18] == 0x3C,
    input_vars[0x18] ^ input_vars[0x19] == 0x53,
    input_vars[0x19] ^ input_vars[0x1A] == 0x54,
    input_vars[0x1A] ^ input_vars[0x1B] == 0x57,
    input_vars[0x1B] ^ input_vars[0x1C] == 0x6C,
    input_vars[0x1C] ^ input_vars[0x1D] == 0x2B,
    input_vars[0x1D] ^ input_vars[0x1E] == 0x1C,
    input_vars[0x1E] ^ input_vars[0x1F] == 0x58,
    input_vars[0x1F] ^ input_vars[0x20] == 0x6F,
    input_vars[0x20] ^ input_vars[0x21] == 0x2B,
    input_vars[0x21] ^ input_vars[0x22] == 0x1C,
    input_vars[0x22] ^ input_vars[0x23] == 0x59,
    input_vars[0x23] ^ input_vars[0x24] == 0x4,
    input_vars[0x24] ^ input_vars[0x25] == 0x6A,
    input_vars[0x25] ^ input_vars[0x26] == 0x36,
    input_vars[0x26] ^ input_vars[0x27] == 0x5C,
    input_vars[0x27] ^ input_vars[0x28] == 0x6A,
    input_vars[0x28] ^ input_vars[0x29] == 0x31,
    input_vars[0x29] ^ input_vars[0x2A] == 0x5E,
    input_vars[0x2A] ^ input_vars[0x2B] == 0x64,
    input_vars[0x2B] ^ input_vars[0x2C] == 0xB,
    input_vars[0x2C] ^ input_vars[0x2D] == 0x1E,
    input_vars[0x2D] ^ input_vars[0x2E] == 0x1E,
    input_vars[0x2E] ^ input_vars[0x2F] == 0x32,
    input_vars[0x2F] ^ input_vars[0x30] == 0x59,
    input_vars[0x30] ^ input_vars[0x31] == 0x58,
    input_vars[0x31] ^ input_vars[0x32] == 0x1B,
    input_vars[0x32] ^ input_vars[0x33] == 0x43,
    input_vars[0x33] ^ input_vars[0x34] == 0x46,
    input_vars[0x34] ^ input_vars[0x35] == 0x41,
    input_vars[0x35] ^ input_vars[0x36] == 0x4E
]
 
# 将所有约束添加到 solver 中
for constraint in constraints:
    solver.add(constraint)
 
# 添加输入的范围约束
for var in input_vars:
    solver.add(var >= 0x20, var <= 0x7E)  # 限制每个 input 变量在可见 ASCII 字符范围内
 
# 找到并展示所有解
solutions = []
while solver.check() == sat:
    model = solver.model()
    solution = [model[input_vars[i]].as_long() for i in range(0x37)]
    solutions.append(solution)
 
    # 将解转换为排除条件，确保寻找不同的解
    solver.add(Or([input_vars[i] != solution[i] for i in range(0x37)]))
 
# 输出所有解
for i, solution in enumerate(solutions, 1):
    readable_solution = ''.join(chr(val) for val in solution)
    print(f"解 {i}: {readable_solution}")

file

Void

file
Script语句中把解密后的源码打印出来即可
file

Yet another crackme

file
解包
file
随便解密就好了：

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
43
44
45
46
47
48
49
50
51
52
53
54
import struct
 
# 给定的映射数组
array = [
    9, 10, 11, 12, 13, 32, 33, 34, 35, 36,
    37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
    47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
    57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
    67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
    77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
    87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
    97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
    107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
    117, 118, 119, 120, 121, 122, 123, 124, 125, 126
]
array2 = [
    58, 38, 66, 88, 78, 39, 80, 125, 64, 106,
    48, 49, 98, 32, 42, 59, 126, 93, 33, 56,
    112, 120, 60, 117, 111, 45, 87, 35, 10, 68,
    61, 77, 11, 55, 121, 74, 107, 104, 65, 63,
    46, 110, 34, 41, 102, 97, 81, 12, 47, 51,
    103, 89, 115, 75, 54, 92, 90, 76, 113, 122,
    114, 52, 72, 70, 50, 94, 91, 73, 84, 95,
    36, 82, 124, 53, 108, 101, 9, 13, 44, 96,
    67, 85, 116, 123, 100, 37, 43, 119, 71, 105,
    118, 69, 99, 79, 86, 109, 62, 83, 40, 57
]
array3 = [16684662107559623091, 13659980421084405632, 11938144112493055466, 17764897102866017993, 11375978084890832581, 14699674141193569951]
num = 14627333968358193854
num2 = 8
 
# 生成逆映射：从 array2 到 array
reverse_map = {array2[i]: array[i] for i in range(len(array))}
 
# 逆向构造字符串
def find_flag():
    result = []
    for target in array3:
        # 反向异或 num 和 target
        num6 = num ^ target
        # 将得到的 num6 转换为字符串
        try:
            bytes_text = struct.pack("<Q", num6)  # 小端字节序解码
            decoded_text = "".join(chr(reverse_map.get(b, b)) for b in bytes_text if b in reverse_map)
            result.append(decoded_text)
        except KeyError:
            # 如果映射不完全，跳过此字符（可以进一步调试）
            continue
 
    return ''.join(result)
 
# 输出可能的 flag 值
flag = find_flag()
print(f"Possible flag: {flag}")

MBTI Radar

IL2CPP的题目，正好之前有过一段时间的研究。
file
用户输入产生MBTI数据，需要产生一一对应的数据
首先还是利用dumper把符号表之类的dump下来
恢复符号表啥的操作就不细说了详情可以看https://bbs.kanxue.com/thread-282821.htm
先用Dnspy观察：
file
可以发现逻辑不多，分析起来难度不会很大
根据Il2cpp的特性，我们知道方法传入的a1其实就是这个类里面一些成员变量组成的结构体之类的，我们可以通过偏移来推断到底是个什么类：
file
像这个charList就是a1+0x30:
于是我们在GameBehaviour__OnClick中就可以发现如下逻辑了：

file
首先看到偏移0x48就是InputName，在onclick中查找
不难发现：

file
这一段就是获取了onClick和charList，做一些基础的对象的处理
下面就是关键逻辑了：
file

调试发现，这里利用我们输入的名字在table中取了索引，然后对索引做了一个似乎是0x24进制的操作，储存到一个值中，我们可以看到UnityEngine_Random__InitState这个是Unity的一个设置随机中的的方法，类似于srand。
接下来过了一些基础操作就可以看到下一个关键逻辑了：

file
这里的0xc其实就是对应题目的12个MBTI
那么MBTI的生成逻辑肯定在里面
file
发现就是利用seed产生的value做运算了
file
到这里比较就完事了。
我们新建一个Unity项目
编辑->资源->创建一个C#脚本
然后点击我们的Main Camera，给Main Camera添加一个组件
file
添加我们的脚本进去，就可以执行我们的脚本了，正好一个很巧的事情发生了，一开始随便输入了一个1，然后程序居然正确了
file
这样正好给我们提供了一个测试思路的用例，1的索引正好就是1，我们写脚本验证一下
这里脚本需要注意：
file
继承的类得是MonoBehavior

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
using UnityEngine;
 
public class NewBehaviourScript: MonoBehaviour
{
    void Start()
    {
        GenerateTypes(12); // 生成并输出12个对应类型
    }
 
    void GenerateTypes(int count)
    {
        int seed = 42; // 设置种子以确保每次生成相同的随机序列
        Random.InitState(seed);
 
        for (int i = 0; i < count; i++)
        {
            float randomValue = Random.value;
            float v7 = randomValue * 201.0f;
            string v8;
 
            // 根据提供的条件，判断对应的类型
            if (v7 < 54.0f)
            {
                if (v7 < 33.0f)
                {
                    if (v7 < 12.0f)
                    {
                        v8 = v7 >= 3.0f ? "INFP" : "NIFJ";
                    }
                    else
                    {
                        v8 = v7 >= 28.0f ? "ENFJ" : "ENFP";
                    }
                }
                else if (v7 < 44.0f)
                {
                    v8 = v7 >= 37.0f ? "INTP" : "INTJ";
                }
                else
                {
                    v8 = v7 >= 50.0f ? "ENTJ" : "ENTP";
                }
            }
            else if (v7 < 147.0f)
            {
                if (v7 < 105.0f)
                {
                    v8 = v7 >= 77.0f ? "ISFJ" : "ISTJ";
                }
                else
                {
                    v8 = v7 >= 122.0f ? "ESFJ" : "ESTJ";
                }
            }
            else if (v7 < 176.0f)
            {
                v8 = v7 >= 158.0f ? "ISFP" : "ISTP";
            }
            else
            {
                v8 = v7 >= 184.0f ? "ESFP" : "ESTP";
            }
 
            Debug.Log(v8); // 输出类型结果
        }
    }
}

file
对应上了，我们就直接开始爆破了

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class NewBehaviourScript : MonoBehaviour
{
    void Start()
    {
        FindMatchingSeed();
    }
 
    void FindMatchingSeed()
    {
        // 定义目标 MBTI 序列
        string[] targetSequence = { "ESFJ", "ESFJ", "INFP", "ESFJ", "ESFP", "ISFJ", "ESTJ", "ESFJ", "ESTJ", "ISFJ", "ISFP", "ISFJ" };
 
        // 枚举所有 a1, a2, a3, a4 和 a5 的组合
        for (int a1 = 0; a1 < 36; a1++)
        {
 
            for (int a2 = 0; a2 < 36; a2++)
            {
                for (int a3 = 0; a3 < 36; a3++)
                {
                    for (int a4 = 0; a4 < 36; a4++)
                    {
                        for (int a5 = 0; a5 < 36; a5++)
                        {
                            for(int a6 = 0;a6 < 36; a6++)
                            {
                                int seed = a1 + 0x24 * a2 + 0x24 * 0x24 * a3 + 0x24 * 0x24 * 0x24 * a4 + 0x24 * 0x24 * 0x24 * 0x24 * a5 + 0x24 * 0x24 * 0x24 * 0x24 * 0x24*a6 ;
 
                                if (CheckMBTISeries(seed, targetSequence))
                                {
                                    Debug.Log($"Match found! a1: {a1}, a2: {a2}, a3: {a3}, a4: {a4}, a5: {a5}，a6:{a6}, seed: {seed}");
                                    return; // 找到匹配项后终止搜索
                                }
                            }
                             
                        }
                    }
                }
                Debug.Log(a2);
            }
        }
 
        Debug.Log("No matching seed found.");
    }
 
    bool CheckMBTISeries(int seed, string[] targetSequence)
    {
        string[] generatedSequence = new string[12];
 
        // 使用生成的种子初始化随机数生成器
        Random.InitState(seed);
 
        // 生成 12 个 MBTI 类型
        for (int i = 0; i < 12; i++)
        {
            float randomValue = Random.value;
            float v7 = randomValue * 201.0f;
            generatedSequence[i] = DetermineMBTI(v7);
        }
 
        // 检查生成的序列是否与目标序列匹配
        for (int i = 0; i < 12; i++)
        {
            if (generatedSequence[i] != targetSequence[i])
                return false; // 一旦有不匹配的情况，返回 false
        }
 
        return true; // 所有值都匹配，返回 true
    }
 
    string DetermineMBTI(float v7)
    {
        // 根据条件生成 MBTI 类型
        if (v7 < 54.0f)
        {
            if (v7 < 33.0f)
            {
                if (v7 < 12.0f)
                {
                    return v7 >= 3.0f ? "INFP" : "NIFJ";
                }
                else
                {
                    return v7 >= 28.0f ? "ENFJ" : "ENFP";
                }
            }
            else if (v7 < 44.0f)
            {
                return v7 >= 37.0f ? "INTP" : "INTJ";
            }
            else
            {
                return v7 >= 50.0f ? "ENTJ" : "ENTP";
            }
        }
        else if (v7 < 147.0f)
        {
            if (v7 < 105.0f)
            {
                return v7 >= 77.0f ? "ISFJ" : "ISTJ";
            }
            else
            {
                return v7 >= 122.0f ? "ESFJ" : "ESTJ";
            }
        }
        else if (v7 < 176.0f)
        {
            return v7 >= 158.0f ? "ISFP" : "ISTP";
        }
        else
        {
            return v7 >= 184.0f ? "ESFP" : "ESTP";
        }
    }
}

这里我只写了六位数据的爆破，需要跑大概半个小时，前面1-5个长度的名字基本都在一分钟内，五个长度需要一分钟
file
写个脚本整理结果就好了

1
2
3
4
5
6
7
8
table = "0123456789abcdefghijklmnopqrstuvwxyz"
index1 = [[1], [4,22],[24,23,3],[5,29,4,27],[30,23,13,3,27],[12,4,14,1,30,22]]
 
 
for i in index1:
    for j in i:
        print(table[j], end='')
    print("",end="_")

file



更多【CTF对抗-HKCERT CTF 部分Re题解】相关视频教程：www.yxfzedu.com




相关文章推荐

记录自己的技术轨迹
文章规则：
1)：文章标题请尽量与文章内容相符
2)：严禁色情、血腥、暴力
3)：严禁发布任何形式的广告贴
4)：严禁发表关于中国的政治类话题
5)：严格遵守中国互联网法律法规
6)：有侵权,疑问可发邮件至service@yxfzedu.com
近期原创 更多

Markdown Editor

友情链接
内核结构FAQ
免责声明
课程目录
Windows内核
游戏逆向(FPS)
技术交流QQ群
342478842215039827137189196
314055665159620936
www.yxfzedu.com是一个分享游戏安全,游戏外挂与反外挂,游戏驱动保护的视频网站！
接各种驱动定制如：游戏读写驱动，软件内存保护，防止调试等功能定制。
出租读写驱动，调试驱动，无痕注入支持各种游戏。
邮箱：service@yxfzedu.com
QQ：851920120
特别说明：不接游戏数据分析，外挂编写，登陆协议等类似业务。