第一步我们就是要找出所有的代码，也就是真实块，我们可以根据一套固定流程来确定寻找。

先祭出老生常谈的一张图：

找到循环头

A -> B -> C -> D -> B

假如说又回到了B，那么B就是循环头，我们根据BFS算法可以找出来  

# ida python
deffind_loop_head(start_ea):
    loop_heads = set()
    queue = deque() # BFS 队列
    blcok = get_basic_block(start_ea) # 获取起始地址所在的基本块
    queue.append((blcok,[]))
whilelen(queue) > 0:
        cur_block, path = queue.popleft()
if cur_block.start_ea in path:
            loop_heads.add(cur_block.start_ea) # 找到循环头
continue
        path = path + [cur_block.start_ea] # 更新路径
        queue.extend((s, path) for s in cur_block.succs()) # 将后继加入队列
    all_loop_heads = list(loop_heads)
    all_loop_heads.sort() # 升序排序，确保主循环头在第一个
print("[+]Find loop heads:",[hex(lh) for lh in all_loop_heads]," -- total:",len(all_loop_heads))
return all_loop_heads

循环头有两个前驱，一个是序言，用与开辟栈空间，初始化变量之类的，一个是汇聚块。

怎么判断哪个是汇聚块呢？汇聚块有很多前驱，而哪些前驱就是我们最关心的————真实快。

ps:其实序言也是真实块之一，别忘了

找出循环头

deffind_converge_addr(loop_head_addr):
    converge_addr = 0
    block = get_basic_block(loop_head_addr) # 循环头
    preds = block.preds() # 获取前驱基本块
    pred_list = list(preds)
iflen(pred_list) == 2: # 标准 ollvm：循环头有两个前驱,一个序言块一个汇聚块
for pred in pred_list:
            tmp_list = list(pred.preds())
iflen(tmp_list) > 1: # 有多个前驱的块是汇聚块
                converge_addr = pred.start_ea
print("[+]Find converge_addr:",hex(converge_addr))
return converge_addr

找出汇聚块

那不是汇聚块就是序言了呗

    for loop_head_addr in loop_heads:
        loop_head_block = get_basic_block(loop_head_addr)
        converge_addr = find_converge_addr(loop_head_addr)
        real_blocks = []
        #找出序言
        loop_head_preds = list(loop_head_block.preds())
        loop_head_preds_addr = [b.start_ea for b in loop_head_preds]
        if loop_head_addr != converge_addr:
            loop_head_preds_addr.remove(converge_addr)
print("序言块:",[hex(x) for x in loop_head_preds_addr])

找出ret块

这个简单，没后继的就是ret块

deffind_ret_block(blocks):
for block in blocks:
        succs = list(block.succs()) # 获取后继块
        succs_list = list(succs)
        end_ea = block.end_ea # end_ea 指向基本块最后一条指令的下一个地址
        last_inst_ea = idc.prev_head(end_ea) # 获取基本块最后一条指令地址
        mnem = idc.print_insn_mnem(last_inst_ea) # 获取指令助记符
iflen(succs_list) == 0: # 没有后继块
if mnem == "retn": # 最后一条指令是 ret 指令
                ori_ret_block = block
# 向上寻找更合适的 ret 块
whileTrue:
                    tmp_block = block.preds()
                    pred_list = list(tmp_block)
iflen(pred_list) == 1: # 只有一个前驱
                        block = pred_list[0]
if get_block_size(block) == 4: # 单指令块
continue
else:
break
else: # 多个前驱或者无前驱
break
# 处理子分发器情况
                block2 = block
                num = 0
                i = 0
whileTrue:
                    i += 1
                    succs_block = block2.succs()
for succ in succs_block:
                        child_succs = succ.succs()
                        succ_list = list(child_succs)
iflen(succ_list) != 0:
                            block2 = succ
                            num += 1
if num > 2:
                        block = ori_ret_block
break
if i > 2:
break
print("[+]ret块",hex(block.start_ea))
return block.start_ea
# 这里是是考虑了可能ret块有前驱，保险起见算一起，可以不用这么多，当然这个代码你直接抄去就行，你可以先自己观察一下哦，有时候自己找ret块也行

找出真实块

def find_all_real_blocks(fun_ea):
    blocks = idaapi.FlowChart(idaapi.get_func(fun_ea))
    loop_heads = find_loop_head(fun_ea)
    all_real_blocks = []
    for loop_head_addr in loop_heads:
        loop_head_block = get_basic_block(loop_head_addr)
        converge_addr = find_converge_addr(loop_head_addr)
        real_blocks = []
        #找出序言
        loop_head_preds = list(loop_head_block.preds())
        loop_head_preds_addr = [b.start_ea for b in loop_head_preds]
        if loop_head_addr != converge_addr:
            loop_head_preds_addr.remove(converge_addr)
print("序言块:",[hex(x) for x in loop_head_preds_addr])
            real_blocks.extend(loop_head_preds_addr)
        converge_block = get_basic_block(converge_addr)
        list_preds = list(converge_block.preds())
        for pred in list_preds:
            end_ea = pred.end_ea
            last_inst_ea = idc.prev_head(end_ea)
            mnem = idc.print_insn_mnem(last_inst_ea)
            size = get_block_size(pred)
            if size > 5: # 大于单指令块且不是跳转指令
                start_ea = pred.start_ea
                real_blocks.append(start_ea)
        real_blocks.sort() # 排序，第一个是序言块
        all_real_blocks.append(real_blocks)
print("子循环头及其子真实块", [hex(child_block_ea) for child_block_ea in real_blocks])
    ret_addr = find_ret_block(blocks)
    all_real_blocks.append(ret_addr)
print("all_real_blocks:",all_real_blocks)
    all_real_block_list = []
    for real_blocks in all_real_blocks:
        if isinstance(real_blocks,list):
            all_real_block_list.extend(real_blocks)
        else:
            all_real_block_list.append(real_blocks)
print(f"\n所有真实块获取完成 真实块数量: {len(all_real_block_list)}")
print(all_real_block_list)

这里也是考虑了多循环头的情况，可以自己看情况改。我们以[RoarCTF 2019]polyre 为例子，附件和所有脚本我都放github上了。
https://github.com/Qmeimei10086/deflat-angr

ida运行结果是：

[+]Findloopheads: ['0x40063f']--total: 1
[+]Findconverge_addr: 0x4020cc
序言块: ['0x400620']
子循环头及其子真实块 ['0x400620', '0x401121', '0x401198', '0x4011de', '0x40124f', '0x40125e', '0x4012a4', '0x4012f6', '0x401305', '0x401326', '0x40136c', '0x4013b2', '0x4013cf', '0x4013ef', '0x401435', '0x401481', '0x401490', '0x4014ae', '0x4014d2', '0x4014e8', '0x4014f7', '0x401506', '0x401521', '0x401567', '0x4015b6', '0x4015c5', '0x4015d4', '0x4015ed', '0x4015fc', '0x401642', '0x401691', '0x4016a0', '0x4016e6', '0x401739', '0x401748', '0x401765', '0x4017ab', '0x4017fc', '0x40180b', '0x401830', '0x401849', '0x401861', '0x4018a7', '0x4018fa', '0x401909', '0x401926', '0x401940', '0x401960', '0x40197d', '0x40199b', '0x4019e1', '0x401a3d', '0x401a4c', '0x401a73', '0x401a8d', '0x401ad3', '0x401b25', '0x401b34', '0x401b4e', '0x401b5d', '0x401b75', '0x401bbb', '0x401c0d', '0x401c1c', '0x401c2b', '0x401c46', '0x401c69', '0x401caf', '0x401d03', '0x401d12', '0x401d2d', '0x401d45', '0x401d54', '0x401d9a', '0x401e00', '0x401e0f', '0x401e2d', '0x401e73', '0x401eb9', '0x401ed6', '0x401efa', '0x401f09', '0x401f2d', '0x401f3c', '0x401f60', '0x401f97', '0x401fa6', '0x401fb5', '0x401fcd', '0x401fe5', '0x401ff4', '0x40200c', '0x40201b', '0x402033', '0x40204d', '0x402072', '0x402096', '0x4020b3', '0x4020c2']
[+]ret块 0x401f54
all_real_blocks: [[4195872, 4198689, 4198808, 4198878, 4198991, 4199006, 4199076, 4199158, 4199173, 4199206, 4199276, 4199346, 4199375, 4199407, 4199477, 4199553, 4199568, 4199598, 4199634, 4199656, 4199671, 4199686, 4199713, 4199783, 4199862, 4199877, 4199892, 4199917, 4199932, 4200002, 4200081, 4200096, 4200166, 4200249, 4200264, 4200293, 4200363, 4200444, 4200459, 4200496, 4200521, 4200545, 4200615, 4200698, 4200713, 4200742, 4200768, 4200800, 4200829, 4200859, 4200929, 4201021, 4201036, 4201075, 4201101, 4201171, 4201253, 4201268, 4201294, 4201309, 4201333, 4201403, 4201485, 4201500, 4201515, 4201542, 4201577, 4201647, 4201731, 4201746, 4201773, 4201797, 4201812, 4201882, 4201984, 4201999, 4202029, 4202099, 4202169, 4202198, 4202234, 4202249, 4202285, 4202300, 4202336, 4202391, 4202406, 4202421, 4202445, 4202469, 4202484, 4202508, 4202523, 4202547, 4202573, 4202610, 4202646, 4202675, 4202690], 4202324]

获取执行循序

这就到了本文最精髓的地方了，我们要找到每个块的后继

对于每一个真实块，我们遵循一套这样的法则

序言执 -> 主分发器 -> 直接跳到我们要的真实块 -> 继续执行看会到哪一个块

重点:  

• 必须先执行序言，这是初始化，执行开栈等操作   

• 直接跳到我们要的真实块，避免每次都要完整执行一遍直到遇到我们要的块，到时候我们用hook解决。

你可能会好奇，那么判断这种广泛使用的功能ollvm是怎么实现的呢？这就是许多文章忽略的一点。在x86汇编里，是通过cmovxx这些汇编实现的在arm64下是用csel指令完成，以后遇到在说。比如一个真实块

loc_40199B:
mov     eax, ds:dword_603054
mov     ecx, ds:dword_603058
mov     edx, eax
sub     edx, 1
imul    eax, edx
and     eax, 1
cmp     eax, 0
setz    sil
cmp     ecx, 0Ah
setl    dil
or      sil, dil
test    sil, 1
mov     eax, 0F37184F0h
mov     ecx, 0A105D2C4h
cmovnz  ecx, eax
mov     [rbp+var_114], ecx
jmp     loc_4020CC

cmovxx通过修改寄存器的值，影响上面分发器的分发，达到不同的块。

但是我们angr遇到不会cmovxx这些汇编分裂出两个分支，而是通过积累一个约束实现，所以我们要手动分裂两个状态，一个执行这条，一个不执行，就会到达两不同的块，然后我们这样储存。

{'0xaaaa':['0xbbb','0xccc']} 

左边放我们zf=1的,右边放zf=0的，方便我们接下来patch

import logging
import angr
from tqdm import tqdm
logging.getLogger('angr').setLevel(logging.ERROR)
defcapstone_decode_cmovxx(insn):
    operands = insn.op_str.replace(" ", "").split(",")
    dst_reg = operands[0]
    src_reg = operands[1]
print(f"cmovxx解析结果: 目标寄存器:{dst_reg}, 源寄存器:{src_reg}")
return dst_reg, src_reg
deffind_state_succ_cmovxx(proj, base, local_state, flag, real_blocks, real_block_addr, path):
# 仅在 find_block_succ 识别为 cmov 时调用
    ins = local_state.block().capstone.insns[0] 
    dst_reg, src_reg = capstone_decode_cmovxx(ins) 
# 逻辑修正：
# flag == True  -> ZF=1 (Zero) -> cmovnz (Not Zero) 条件不满足 -> 不执行 Move -> Pass
# flag == False -> ZF=0 (Not Zero) -> cmovnz (Not Zero) 条件满足 -> 执行 Move
ifnot flag: # 需要执行 Move
try:
# 修正：state.regs 没有 .get() 方法，用 getattr
            src_val = getattr(local_state.regs, src_reg)
setattr(local_state.regs, dst_reg, src_val)
except Exception as e:
print(f"寄存器访问错误: {e}")
# 关键修正：手动跳过这条 cmov 指令！防止 Angr 再次执行它
    local_state.regs.ip += ins.size
    sm = proj.factory.simgr(local_state)
while(len(sm.active)):
for active_state in sm.active:
try:
                ins_offset = active_state.addr - base
if ins_offset in real_blocks:
                    value = path[real_block_addr]
if ins_offset notin value:
                        value.append(ins_offset)
return ins_offset
except:
pass
        sm.step(num_inst=1)
deffind_block_succ(proj, base, func_offset, state, real_block_addr, real_blocks, path):
    msm = proj.factory.simgr(state)  # 构造模拟器
whilelen(msm.active):
for active_state in msm.active:
#print(active_state.block().capstone.insns[0])
            offset = active_state.addr - base
#print("当前偏移地址:", hex(offset),"寻找真实块:", hex(real_block_addr))
if offset == real_block_addr:  # 找到真实块
print("找到真实块:", hex(real_block_addr))
                mstate = active_state.copy()  # 复制state,为后继块的获取做准备
                msm2 = proj.factory.simgr(mstate)
                msm2.step(num_inst=1)  # 让状态进到块内的下一条指令位置，避免和外层状态混淆
whilelen(msm2.active):
for mactive_state in msm2.active:
#print(mactive_state.block().capstone.insns[0])
                        ins_offset = mactive_state.addr - base
if ins_offset in real_blocks:  # 无分支块（或无条件跳转）
# 在无条件跳转中,并且有至少两条路径同时执行到真实块时,取非ret块的真实块
                            msm2_len = len(msm2.active)
if msm2_len > 1:
                                tmp_addrs = []
for s in msm2.active:
                                    moffset = s.addr - base
                                    tmp_value = path[real_block_addr]
if moffset in real_blocks and moffset notin tmp_value:
                                        tmp_addrs.append(moffset)
iflen(tmp_addrs) > 1:
print("当前至少有两个路径同时执行到真实块:", [hex(tmp_addr) for tmp_addr in tmp_addrs])
                                    ret_addr = real_blocks[len(real_blocks) - 1]
if ret_addr in tmp_addrs:
                                        tmp_addrs.remove(ret_addr)
                                    ins_offset = tmp_addrs[0]
print("两个路径同时执行到真实块最后取得:", hex(ins_offset))
                            value = path[real_block_addr]
if ins_offset notin value:
                                value.append(ins_offset)
print(f"无条件跳转块关系:{hex(real_block_addr)}-->{hex(ins_offset)}")
return
# 可能是 cmovnz 分支指令
                        ins = mactive_state.block().capstone.insns[0]
if ins.mnemonic == 'cmovnz'or ins.mnemonic == 'cmovne':
print("发现 cmovnz/cmovne 指令，进行分支处理:", hex(ins_offset))
#分裂双情况
                            state_true = mactive_state.copy()
                            state_true_succ_addr = find_state_succ_cmovxx(proj, base, state_true, True, real_blocks, real_block_addr, path)
                            state_false = mactive_state.copy()
                            state_false_succ_addr = find_state_succ_cmovxx(proj, base, state_false, False, real_blocks, real_block_addr, path)
if state_true_succ_addr isNoneor state_false_succ_addr isNone:
print("cmovnz/cmovne错误指令地址:", hex(ins_offset))
print(f"cmovnz/cmovne后继有误:{hex(real_block_addr)}-->{hex(state_true_succ_addr) if state_true_succ_addr isnotNoneelse state_true_succ_addr},"
f"{hex(state_false_succ_addr) if state_false_succ_addr isnotNoneelse state_false_succ_addr}")
return"erro"
#cmovne
print(f"cmovnz/cmovne分支跳转块关系:{hex(real_block_addr)}-->{hex(state_true_succ_addr)} zf = 1,  {hex(state_false_succ_addr)} zf != 1")
#print(f"csel分支跳转块关系:{hex(real_block_addr)}-->{hex(state_true_succ_addr)},{hex(state_false_succ_addr)}")
return
#与cmovnz相反
if ins.mnemonic == 'cmovz'or ins.mnemonic == 'cmove':
print("发现 cmovz/cmove 指令，进行分支处理:", hex(ins_offset))
                            state_true = mactive_state.copy()
                            state_true_succ_addr = find_state_succ_cmovxx(proj, base, state_true, False, real_blocks, real_block_addr, path)
                            state_false = mactive_state.copy()
                            state_false_succ_addr = find_state_succ_cmovxx(proj, base, state_false, True, real_blocks, real_block_addr, path)
if state_true_succ_addr isNoneor state_false_succ_addr isNone:
print("cmovz/cmove误指令地址:", hex(ins_offset))
print(f"cmovz/cmove后继有误:{hex(real_block_addr)}-->{hex(state_true_succ_addr) if state_true_succ_addr isnotNoneelse state_true_succ_addr},"
f"{hex(state_false_succ_addr) if state_false_succ_addr isnotNoneelse state_false_succ_addr}")
return"erro"
#cmovne
print(f"cmovz/cmove分支跳转块关系:{hex(real_block_addr)}-->{hex(state_true_succ_addr)} zf = 1,  {hex(state_false_succ_addr)} zf != 1")
#print(f"csel分支跳转块关系:{hex(real_block_addr)}-->{hex(state_true_succ_addr)},{hex(state_false_succ_addr)}")
return
                    msm2.step(num_inst=1)
# 真实块集合中的最后一个基本块如果最后没找到后继,说明是return块,直接返回
return
        msm.step(num_inst=1)
defangr_main(real_blocks,func_offset,file_path):
    proj = angr.Project(file_path, auto_load_libs=False) 
    base = 0
    func_addr = base + func_offset
    init_state = proj.factory.blank_state(addr=func_addr)
    init_state.options.add(angr.options.CALLLESS)
    path = {addr: [] for addr in real_blocks}
    ret_addr = real_blocks[len(real_blocks) - 1]
    first_block = proj.factory.block(func_addr)
    first_block_insns = first_block.capstone.insns
# 主序言的最后一条指令
    first_block_last_ins = first_block_insns[len(first_block_insns) - 1]
print(hex(first_block_last_ins.address))
for real_block_addr in tqdm(real_blocks):
if ret_addr == real_block_addr:
continue
        state = init_state.copy()
print("正在寻找:",hex(real_block_addr))
defjump_to_address(state):
#print(state.regs.pc)
            state.regs.pc = base + real_block_addr - 6
print("跳转到地址:", hex(base + real_block_addr - 6))
            proj.unhook(0x400675)
print(hex(real_block_addr),hex(func_offset))
if real_block_addr != func_offset:
print("序言结束")
            proj.hook(0x400675, jump_to_address, first_block_last_ins.size)
        ret = find_block_succ(proj, base, func_offset, state, real_block_addr, real_blocks, path)
if ret == "erro":
return
    hex_dict = {
hex(key): [hex(value) for value in values]
for key, values in path.items()
    }
for i in hex_dict.keys():
print(f"{i}:  {hex_dict[i]}")
print(hex_dict)
return hex_dict
all_real_blocks: list[int] =[4195872, 4198689, 4198808, 4198878, 4198991, 4199006, 4199076, 4199158, 4199173, 4199206, 4199276, 4199346, 4199375, 4199407, 4199477, 4199553, 4199568, 4199598, 4199634, 4199656, 4199671, 4199686, 4199713, 4199783, 4199862, 4199877, 4199892, 4199917, 4199932, 4200002, 4200081, 4200096, 4200166, 4200249, 4200264, 4200293, 4200363, 4200444, 4200459, 4200496, 4200521, 4200545, 4200615, 4200698, 4200713, 4200742, 4200768, 4200800, 4200829, 4200859, 4200929, 4201021, 4201036, 4201075, 4201101, 4201171, 4201253, 4201268, 4201294, 4201309, 4201333, 4201403, 4201485, 4201500, 4201515, 4201542, 4201577, 4201647, 4201731, 4201746, 4201773, 4201797, 4201812, 4201882, 4201984, 4201999, 4202029, 4202099, 4202169, 4202198, 4202234, 4202249, 4202285, 4202300, 4202336, 4202391, 4202406, 4202421, 4202445, 4202469, 4202484, 4202508, 4202523, 4202547, 4202573, 4202610, 4202646, 4202675, 4202690, 4202324]
angr_main(all_real_blocks, 0x400620, "D:\\reverse\\Angr\\polyre")

几个关键点  

def jump_to_address(state):
    #print(state.regs.pc)
    state.regs.pc = base + real_block_addr - 6
print("跳转到地址:", hex(base + real_block_addr - 6))
    proj.unhook(0x400675)

我们通过hook主分发器的最后一个指令，运行到直接跳到我们要的块，然后记得unhook，不然到时候执行回来又跳到那里去了，就循环了。

为什么要 -6，我只能说理论上应该不用加偏移，但是实际上不加的化angr不能正确的识别指令，capstone解码出来的混乱的，这个-6是我摸索出来的，如果不行你们可以试试别的，记得把汇编输出出来对一下就行（我把它注释了）

运行结果：

0x400620:  ['0x401121']
0x401121:  ['0x401198']
0x401198:  ['0x401f60', '0x4011de']
0x4011de:  ['0x401f60', '0x40124f']
0x40124f:  ['0x40125e']
0x40125e:  ['0x401f97', '0x4012a4']
0x4012a4:  ['0x401f97', '0x4012f6']
0x4012f6:  ['0x401305']
0x401305:  ['0x401326']
0x401326:  ['0x401fa6', '0x40136c']
0x40136c:  ['0x401fa6', '0x4013b2']
0x4013b2:  ['0x4015d4', '0x4013cf']
0x4013cf:  ['0x4013ef']
0x4013ef:  ['0x401fb5', '0x401435']
0x401435:  ['0x401fb5', '0x401481']
0x401481:  ['0x401490']
0x401490:  ['0x4014ae', '0x4014f7']
0x4014ae:  ['0x4014d2']
0x4014d2:  ['0x4014e8']
0x4014e8:  ['0x4015d4']
0x4014f7:  ['0x401506']
0x401506:  ['0x401521']
0x401521:  ['0x401fcd', '0x401567']
0x401567:  ['0x401fcd', '0x4015b6']
0x4015b6:  ['0x4015c5']
0x4015c5:  ['0x40125e']
0x4015d4:  ['0x4015ed']
0x4015ed:  ['0x4015fc']
0x4015fc:  ['0x401fe5', '0x401642']
0x401642:  ['0x401fe5', '0x401691']
0x401691:  ['0x4016a0']
0x4016a0:  ['0x401ff4', '0x4016e6']
0x4016e6:  ['0x401ff4', '0x401739']
0x401739:  ['0x401748']
0x401748:  ['0x401d54', '0x401765']
0x401765:  ['0x40200c', '0x4017ab']
0x4017ab:  ['0x40200c', '0x4017fc']
0x4017fc:  ['0x40180b']
0x40180b:  ['0x401830']
0x401830:  ['0x401849']
0x401849:  ['0x401861']
0x401861:  ['0x40201b', '0x4018a7']
0x4018a7:  ['0x40201b', '0x4018fa']
0x4018fa:  ['0x401909']
0x401909:  ['0x401c2b', '0x401926']
0x401926:  ['0x401940']
0x401940:  ['0x401960']
0x401960:  ['0x401a73', '0x40197d']
0x40197d:  ['0x40199b']
0x40199b:  ['0x402033', '0x4019e1']
0x4019e1:  ['0x402033', '0x401a3d']
0x401a3d:  ['0x401a4c']
0x401a4c:  ['0x401b4e']
0x401a73:  ['0x401a8d']
0x401a8d:  ['0x40204d', '0x401ad3']
0x401ad3:  ['0x40204d', '0x401b25']
0x401b25:  ['0x401b34']
0x401b34:  ['0x401b4e']
0x401b4e:  ['0x401b5d']
0x401b5d:  ['0x401b75']
0x401b75:  ['0x402072', '0x401bbb']
0x401bbb:  ['0x402072', '0x401c0d']
0x401c0d:  ['0x401c1c']
0x401c1c:  ['0x401849']
0x401c2b:  ['0x401c46']
0x401c46:  ['0x401c69']
0x401c69:  ['0x402096', '0x401caf']
0x401caf:  ['0x402096', '0x401d03']
0x401d03:  ['0x401d12']
0x401d12:  ['0x401d2d']
0x401d2d:  ['0x401d45']
0x401d45:  ['0x4015fc']
0x401d54:  ['0x4020b3', '0x401d9a']
0x401d9a:  ['0x4020b3', '0x401e00']
0x401e00:  ['0x401e0f']
0x401e0f:  ['0x401e2d']
0x401e2d:  ['0x4020c2', '0x401e73']
0x401e73:  ['0x4020c2', '0x401eb9']
0x401eb9:  ['0x401ed6', '0x401f09']
0x401ed6:  ['0x401efa']
0x401efa:  ['0x401f3c']
0x401f09:  ['0x401f2d']
0x401f2d:  ['0x401f3c']
0x401f3c:  ['0x401f54']
0x401f60:  ['0x4011de']
0x401f97:  ['0x4012a4']
0x401fa6:  ['0x40136c']
0x401fb5:  ['0x401435']
0x401fcd:  ['0x401567']
0x401fe5:  ['0x401642']
0x401ff4:  ['0x4016e6']
0x40200c:  ['0x4017ab']
0x40201b:  ['0x4018a7']
0x402033:  ['0x4019e1']
0x40204d:  ['0x401ad3']
0x402072:  ['0x401bbb']
0x402096:  ['0x401caf']
0x4020b3:  ['0x401d9a']
0x4020c2:  ['0x401e73']
0x401f54:  []

假如只有一个后继的，我们直接把最后一条指令patch为：

jmp 后继地址

假如有双后继，根据我们前面说的，列表左边是zf=1，右边是zf=0，从cmovxx开始，patch为：

jz 列表左侧地址
jmp 列表右侧地址

剩下的地方用nop填充，然后再后面把没用到的块给nop了。

from collections import deque
import ida_funcs
import idaapi
import idautils
import idc
import keystone
defpatch_ins_to_nop(ins):
    size = idc.get_item_size(ins)
for i inrange(size):
        idc.patch_byte(ins + i,0x90)
defpatch_bytes(addr, data):
for i, b inenumerate(data):
        idc.patch_byte(addr + i, b)
deffill_nop(start_ea, end_ea):
# [FIX 1] 应该是 end - start，否则是负数
    size = end_ea - start_ea 
if size > 0:
# [FIX 2] 使用 patch_bytes 批量写入
        patch_bytes(start_ea, b'\x90' * size)
defget_block_by_address(ea):
    func = idaapi.get_func(ea)
    blocks = idaapi.FlowChart(func)
for block in blocks:
if block.start_ea <= ea < block.end_ea:
return block
returnNone
defgenerate_jmp_code(src, dst):
# E9 xx xx xx xx
    offset = dst - (src + 5)
returnb'\xE9' + offset.to_bytes(4, 'little', signed=True)
defgenerate_jz_code(src, dst):
# 0F 84 xx xx xx xx
    offset = dst - (src + 6)
returnb'\x0F\x84' + offset.to_bytes(4, 'little', signed=True)
defpatch_branch(patch_dict):
for ea in patch_dict:
        values = patch_dict[ea]
iflen(values) == 0:#如果后继块为0,基本都是return块,不需要patch,直接跳过
continue
        block = get_block_by_address(int(ea, 16))
        start_ea = block.start_ea
        end_ea = block.end_ea
        last_ins_ea = idc.prev_head(end_ea)#因为block.end_ea获取的地址是块最后一个地址的下一个地址,所以需要向上取一个地址
iflen(values) == 2:
for ins in idautils.Heads(start_ea,end_ea):
if idc.print_insn_mnem(ins).startswith("cmov"):
print("find cmov")
                    jz_code = generate_jz_code(ins, int(values[0],16))
                    jmp_code = generate_jmp_code(ins + len(jz_code), int(values[1],16))
# [FIX 2] 实际写入内存！
                    patch_bytes(ins, jz_code)
                    patch_bytes(ins + len(jz_code), jmp_code)
# 3. 填充 NOP
                    nop_start = ins + len(jz_code) + len(jmp_code)
                    fill_nop(nop_start, end_ea)
iflen(values) == 1:
            mnem = idc.print_insn_mnem(last_ins_ea)
if mnem.startswith("jmp"):
                jmp_code = generate_jmp_code(last_ins_ea, int(values[0],16))
                patch_bytes(last_ins_ea, jmp_code)
                nop_start = last_ins_ea + len(jmp_code)
                fill_nop(nop_start, end_ea)
deffind_all_useless_block(func_ea,real_blocks):
    blocks = idaapi.FlowChart(idaapi.get_func(func_ea))
    local_real_blocks = real_blocks.copy()
    useless_blocks = []
# local_real_blocks.extend(succ.start_ea for succ in cur_block.succs())
for block in blocks:
        start_ea = block.start_ea
        end_ea = block.end_ea
if start_ea notin local_real_blocks:
            useless_blocks.append([start_ea,end_ea])
print("所有的无用块:",[b for b in useless_blocks])
return useless_blocks
defpatch_useless_blocks(useless_blocks):
# print(useless_blocks)
for useless_block in useless_blocks:
print(f"Nop-ing useless block from {hex(useless_block[0])} to {useless_block[1]}")
        fill_nop(useless_block[0], useless_block[1])
print("无用块nop完成")
func_ea = 0x400620
all_real_blocks =[4195872, 4198689, 4198808, 4198878, 4198991, 4199006, 4199076, 4199158, 4199173, 4199206, 4199276, 4199346, 4199375, 4199407, 4199477, 4199553, 4199568, 4199598, 4199634, 4199656, 4199671, 4199686, 4199713, 4199783, 4199862, 4199877, 4199892, 4199917, 4199932, 4200002, 4200081, 4200096, 4200166, 4200249, 4200264, 4200293, 4200363, 4200444, 4200459, 4200496, 4200521, 4200545, 4200615, 4200698, 4200713, 4200742, 4200768, 4200800, 4200829, 4200859, 4200929, 4201021, 4201036, 4201075, 4201101, 4201171, 4201253, 4201268, 4201294, 4201309, 4201333, 4201403, 4201485, 4201500, 4201515, 4201542, 4201577, 4201647, 4201731, 4201746, 4201773, 4201797, 4201812, 4201882, 4201984, 4201999, 4202029, 4202099, 4202169, 4202198, 4202234, 4202249, 4202285, 4202300, 4202336, 4202391, 4202406, 4202421, 4202445, 4202469, 4202484, 4202508, 4202523, 4202547, 4202573, 4202610, 4202646, 4202675, 4202690, 4202324]
useless_blocks = find_all_useless_block(func_ea,all_real_blocks)
patch_branch({'0x400620': ['0x401121'], '0x401121': ['0x401198'], '0x401198': ['0x401f60', '0x4011de'], '0x4011de': ['0x401f60', '0x40124f'], '0x40124f': ['0x40125e'], '0x40125e': ['0x401f97', '0x4012a4'], '0x4012a4': ['0x401f97', '0x4012f6'], '0x4012f6': ['0x401305'], '0x401305': ['0x401326'], '0x401326': ['0x401fa6', '0x40136c'], '0x40136c': ['0x401fa6', '0x4013b2'], '0x4013b2': ['0x4015d4', '0x4013cf'], '0x4013cf': ['0x4013ef'], '0x4013ef': ['0x401fb5', '0x401435'], '0x401435': ['0x401fb5', '0x401481'], '0x401481': ['0x401490'], '0x401490': ['0x4014ae', '0x4014f7'], '0x4014ae': ['0x4014d2'], '0x4014d2': ['0x4014e8'], '0x4014e8': ['0x4015d4'], '0x4014f7': ['0x401506'], '0x401506': ['0x401521'], '0x401521': ['0x401fcd', '0x401567'], '0x401567': ['0x401fcd', '0x4015b6'], '0x4015b6': ['0x4015c5'], '0x4015c5': ['0x40125e'], '0x4015d4': ['0x4015ed'], '0x4015ed': ['0x4015fc'], '0x4015fc': ['0x401fe5', '0x401642'], '0x401642': ['0x401fe5', '0x401691'], '0x401691': ['0x4016a0'], '0x4016a0': ['0x401ff4', '0x4016e6'], '0x4016e6': ['0x401ff4', '0x401739'], '0x401739': ['0x401748'], '0x401748': ['0x401d54', '0x401765'], '0x401765': ['0x40200c', '0x4017ab'], '0x4017ab': ['0x40200c', '0x4017fc'], '0x4017fc': ['0x40180b'], '0x40180b': ['0x401830'], '0x401830': ['0x401849'], '0x401849': ['0x401861'], '0x401861': ['0x40201b', '0x4018a7'], '0x4018a7': ['0x40201b', '0x4018fa'], '0x4018fa': ['0x401909'], '0x401909': ['0x401c2b', '0x401926'], '0x401926': ['0x401940'], '0x401940': ['0x401960'], '0x401960': ['0x401a73', '0x40197d'], '0x40197d': ['0x40199b'], '0x40199b': ['0x402033', '0x4019e1'], '0x4019e1': ['0x402033', '0x401a3d'], '0x401a3d': ['0x401a4c'], '0x401a4c': ['0x401b4e'], '0x401a73': ['0x401a8d'], '0x401a8d': ['0x40204d', '0x401ad3'], '0x401ad3': ['0x40204d', '0x401b25'], '0x401b25': ['0x401b34'], '0x401b34': ['0x401b4e'], '0x401b4e': ['0x401b5d'], '0x401b5d': ['0x401b75'], '0x401b75': ['0x402072', '0x401bbb'], '0x401bbb': ['0x402072', '0x401c0d'], '0x401c0d': ['0x401c1c'], '0x401c1c': ['0x401849'], '0x401c2b': ['0x401c46'], '0x401c46': ['0x401c69'], '0x401c69': ['0x402096', '0x401caf'], '0x401caf': ['0x402096', '0x401d03'], '0x401d03': ['0x401d12'], '0x401d12': ['0x401d2d'], '0x401d2d': ['0x401d45'], '0x401d45': ['0x4015fc'], '0x401d54': ['0x4020b3', '0x401d9a'], '0x401d9a': ['0x4020b3', '0x401e00'], '0x401e00': ['0x401e0f'], '0x401e0f': ['0x401e2d'], '0x401e2d': ['0x4020c2', '0x401e73'], '0x401e73': ['0x4020c2', '0x401eb9'], '0x401eb9': ['0x401ed6', '0x401f09'], '0x401ed6': ['0x401efa'], '0x401efa': ['0x401f3c'], '0x401f09': ['0x401f2d'], '0x401f2d': ['0x401f3c'], '0x401f3c': ['0x401f54'], '0x401f60': ['0x4011de'], '0x401f97': ['0x4012a4'], '0x401fa6': ['0x40136c'], '0x401fb5': ['0x401435'], '0x401fcd': ['0x401567'], '0x401fe5': ['0x401642'], '0x401ff4': ['0x4016e6'], '0x40200c': ['0x4017ab'], '0x40201b': ['0x4018a7'], '0x402033': ['0x4019e1'], '0x40204d': ['0x401ad3'], '0x402072': ['0x401bbb'], '0x402096': ['0x401caf'], '0x4020b3': ['0x401d9a'], '0x4020c2': ['0x401e73'], '0x401f54': []})
patch_useless_blocks(useless_blocks)
ida_funcs.reanalyze_function(ida_funcs.get_func(func_ea))#刷新函数控制流图
print("控制流图已刷新")

这里一个小细节,我们先找出所有的无用块列表，得到开始地址与结束地址，然后在进行控制流的patch，最后根据前面获取的无用块列表，nop无用块，如果先patch控制流在寻找无用块，找出来的无用块是错误的。

恢复完的到代码：   

__int64 __fastcall main(int a1, char **a2, char **a3){
signed __int64 v4; // [rsp+1E0h] [rbp-110h]
int n6; // [rsp+1E8h] [rbp-108h]
int n64; // [rsp+1ECh] [rbp-104h]
int n64_1; // [rsp+1ECh] [rbp-104h]
  _BYTE s1[48]; // [rsp+1F0h] [rbp-100h] BYREF
  _BYTE s[60]; // [rsp+220h] [rbp-D0h] BYREF
unsignedint v10; // [rsp+25Ch] [rbp-94h]
  _BYTE *p_s; // [rsp+260h] [rbp-90h]
int n64_3; // [rsp+26Ch] [rbp-84h]
bool v13; // [rsp+272h] [rbp-7Eh]
unsigned __int8 n10; // [rsp+273h] [rbp-7Dh]
int n10_1; // [rsp+274h] [rbp-7Ch]
  _BYTE *v16; // [rsp+278h] [rbp-78h]
int v17; // [rsp+284h] [rbp-6Ch]
int n6_1; // [rsp+288h] [rbp-68h]
bool v19; // [rsp+28Fh] [rbp-61h]
  _BYTE *p_s_1; // [rsp+290h] [rbp-60h]
int n64_4; // [rsp+298h] [rbp-58h]
bool v22; // [rsp+29Fh] [rbp-51h]
signed __int64 v23; // [rsp+2A0h] [rbp-50h]
bool v24; // [rsp+2AFh] [rbp-41h]
  __int64 v25; // [rsp+2B0h] [rbp-40h]
  __int64 v26; // [rsp+2B8h] [rbp-38h]
signed __int64 v27; // [rsp+2C0h] [rbp-30h]
  __int64 v28; // [rsp+2C8h] [rbp-28h]
int n64_2; // [rsp+2D0h] [rbp-20h]
int v30; // [rsp+2D4h] [rbp-1Ch]
signed __int64 *v31; // [rsp+2D8h] [rbp-18h]
int v32; // [rsp+2E0h] [rbp-10h]
int v33; // [rsp+2E4h] [rbp-Ch]
bool v34; // [rsp+2EBh] [rbp-5h]
  v10 = 0;
memset(s, 0, 0x30u);
memset(s1, 0, sizeof(s1));
printf("Input:");
  p_s = s;
  __isoc99_scanf("%s", s);
for ( n64 = 0; ; ++n64 )
  {
    n64_3 = n64;
    v13 = n64 < 64;
if ( n64 >= 64 )
break;
    n10 = s[n64];
    n10_1 = n10;
if ( n10 == 10 )
    {
      v16 = &s[n64];
      *v16 = 0;
break;
    }
    v17 = n64 + 1;
  }
for ( n6 = 0; ; ++n6 )
  {
    n6_1 = n6;
    v19 = n6 < 6;
if ( n6 >= 6 )
break;
    p_s_1 = s;
    v4 = *(_QWORD *)&s[8 * n6];
for ( n64_1 = 0; ; ++n64_1 )
    {
      n64_4 = n64_1;
      v22 = n64_1 < 64;
if ( n64_1 >= 64 )
break;
      v23 = v4;
      v24 = v4 < 0;
if ( v4 >= 0 )
      {
        v27 = v4;
        v28 = 2 * v4;
        v4 *= 2LL;
      }
else
      {
        v25 = 2 * v4;
        v26 = 2 * v4;
        v4 = (2 * v4) ^ 0xB0004B7679FA26B3LL;
      }
      n64_2 = n64_1;
    }
    v30 = 8 * n6;
    v31 = (signed __int64 *)&s1[8 * n6];
    *v31 = v4;
    v32 = n6 + 1;
  }
  v33 = memcmp(s1, &s2_, 0x30u);
  v34 = v33 != 0;
if ( v33 )
puts("Wrong!");
else
puts("Correct!");
return v10;
}

最后exp:    

import struct
# Data from s2_
s2_bytes = [
0x96, 0x62, 0x53, 0x43, 0x6d, 0xf2, 0x8f, 0xbc, 
0x16, 0xee, 0x30, 0x5, 0x78, 0x0, 0x1, 0x52, 
0xec, 0x8, 0x5f, 0x93, 0xea, 0xb5, 0xc0, 0x4d, 
0x50, 0xf4, 0x53, 0xd8, 0xaf, 0x90, 0x2b, 0x34, 
0x81, 0x36, 0x2c, 0xaa, 0xbc, 0xe, 0x25, 0x8b, 
0xe4, 0x8a, 0xc6, 0xa2, 0x81, 0x9f, 0x75, 0x55
]
POLY = 0xB0004B7679FA26B3
# Convert bytes to QWORDs (little endian)
qwords = []
for i inrange(0, len(s2_bytes), 8):
    chunk = s2_bytes[i:i+8]
    val = struct.unpack('<Q', bytes(chunk))[0]
    qwords.append(val)
start_vals = []
for val in qwords:
    curr = val
for _ inrange(64):
if curr & 1:
            curr = (curr ^ POLY) >> 1
            curr |= 0x8000000000000000
else:
            curr = curr >> 1
    start_vals.append(curr)
# Convert back to bytes
flag = b''
for val in start_vals:
    flag += struct.pack('<Q', val)
print(flag)
try:
print("Flag:", flag.decode('utf-8'))
except:
pass
#flag{6ff29390-6c20-4c56-ba70-a95758e3d1f8}

第十届安全开发者峰会【议题征集】-欢迎投稿

8月14日，智谱AI对外推出全新模型GLM‑5.3。该版本并未更换底层基座，依靠后训练Scaling技术实现能力跃迁，拓展长程任务训练规模、丰富环境样本、拉长后训练周期，在编程、智能体执行、网络安全多个维度实现显著进步，被官方称作现阶段编程能力最强的开源大模型。

整体编程与Agent综合实力逼近Claude Fable 5，实际编码表现优于多数国产同类模型。

在白盒代码审计、漏洞挖掘等安全场景，GLM‑5.3性能对标Mythos 5，具备不错的网络安全防御落地潜力，可服务安全工程师做代码审查、漏洞研判等工作。

• 工具端：官方编程工具ZCode、自动化效率工具AutoClaw现已上线，GLM Coding Plan订阅向全部用户开放；TraeCode、扣子、CodeBuddy等第三方编码平台开启抢先体验。8月14日13点，GLM Coding Plan全部用户使用额度完成重置。

• API接口：即将对外开放。

• 权重开源：完成安全评估与模型加固后，两周后开放模型权重；会约束模型潜在攻击能力，保留安全防御相关能力。

资讯来源：智谱AI官方

目标应用: 一款网络摄像头工具，家里人经常用来查看摄像头，但是软件中塞了一大堆牛皮癣广告。

广告行为: 开屏广告，热点区域广告，摇一摇跳转，关闭按钮不方便点击且容易误触广告，各种坑老陷阱。

软件中的广告还会区别对待新老用户:

定位广告来源

首先定位广告来源，反编译出来的代码没有混淆，直接搜索关键字就可以定位到开屏广告的位置。

这里向上追一下调用关系，查到是从 AndroidManifest.xml 中的 LauncherActivity 开始的，那广告入口就是这里。

接下来就分析下广告展示逻辑并跳过它：

可以看到这里有广告开关，看一下怎么切换到免广告。

这是 AdControl.sFreeAd 控制的新用户免广告，再看一下另一个条件。

看起来是个软件广告总开关，往后追了一下，这里是个开发者的后门控制开关。

那就直接选择从这里入手去广告，先看一下 smali：

直接让 906 行的条件判断进入 sThirdAdType = 0; 的代码块即可, 所以在 905 行插入一行 const/4 p0, 0x1 把 p0 寄存器强制改为 true，效果如下。

这样就可以达到目的了。

重打包

接下来重新打包软件并签名，所以要先处理一下签名校验问题，通过反编译的代码可以看到这里有个检验的逻辑。

在每次 activity 的 onCreate 中触发 appVerification 方法，这里也是有开关控制的，而且是编译期常量。

所以这里还是继续改 smali

这里把 sput-boolean v0, Lcom/macrovideo/sdk/GlobalConfiguration;->sIsSignatureVerification:Z 的 v0 寄存器改为 v1 即可。

把 sIsCheckRoot 也一起改为 false 了，然后尝试打包签名并运行，但是应用启动后闪退了。

用 logcat 查看下闪退的代码位置 adb logcat -c && adb logcat -s AndroidRuntime:E

---------beginningofcrash
08-10 17:45:51.946 15265 15281 E AndroidRuntime: FATAL EXCEPTION:Thread-2
08-10 17:45:51.946 15265 15281 E AndroidRuntime: Process:com.***.***,PID:15265
08-10 17:45:51.946 15265 15281 E AndroidRuntime: java.lang.RuntimeException:entryclasses6.dexistamper
08-10 17:45:51.946 15265 15281 E AndroidRuntime:atcom.security.shell.V5App$31.v(NativeMethod)
08-10 17:45:51.946 15265 15281 E AndroidRuntime:atcom.security.shell.V5App$1.e(UnknownSource:11)
08-10 17:45:51.946 15265 15281 E AndroidRuntime:atcom.security.shell.V5App$31.v(NativeMethod)
08-10 17:45:51.946 15265 15281 E AndroidRuntime:atcom.security.shell.V5App$1.run(UnknownSource:8)
08-10 17:45:51.946 15265 15281 E AndroidRuntime:atjava.lang.Thread.run(Thread.java:1563)

搜了下关键字 com.security.shell.V5App, 软件采用的是顶象加固，接下来准备进行脱壳，但是通过反编译的代码分析发现 dex 代码并没有用壳加固，所以直接改掉 AndroidManifest.xml 中的 application 配置。

这里的 appComponentFactory 也要一起改掉：

然后重新打包，签名，安装，软件启动成功，广告也正常关闭，ok

总体来说整个过程还是比较顺利的，先定位广告来源，分析展示逻辑并 nop 掉，过签名校验，替换加固代码入口，重打包。因为整个操作都是在 Java 层，而且应用本身就有关闭广告的逻辑，所以基本上是没有什么难度的，最终也是成功实现了去广告的效果。(没有经过混淆的代码看起来真的是太舒服了)

本文仅用于软件逆向分析与技术经验分享，旨在探讨移动应用的实现原理及相关技术。

文中涉及的应用名称、关键参数、接口信息、代码及其他敏感内容均已进行脱敏或适当处理。本文内容仅供学习、研究和技术交流使用，请勿将相关技术用于侵犯他人合法权益、破坏软件正常运行或其他违法违规行为，由此产生的任何后果与本文作者无关。

如涉及相关软件的合法权益，请联系作者进行处理。

第十届安全开发者峰会【议题征集】-欢迎投稿

技术不分咖位，热爱才是一切。

这一期的两位嘉宾，有着一段特殊的关系——他是他的引路人，他是他带出来的人。

茶已备好。这次我们坐在成都的茶馆里，慢慢聊。

Thanos 王志鹏，为辰信安技术总监，圈内人送外号“车联网安全黄埔军校校长”。

智能网联汽车与物联网安全专家，国家级赛事裁判及规则委员，多项国家标准参编者，具身智能安全专家。

他的技术故事，始于少年时与父亲的“猫鼠游戏”——破解系统密码、破解BIOS密码，父亲一气之下用铆钉把机箱封死。后来，他在FF0000、1937CN技术大佬启蒙下拿到第一个Shell，参军、创业、在车联网安全领域扎根。而真正让他被圈内记住的，除了技术本身，还有一件事：他带出来的年轻人，如今遍布全国各大车企和检测机构。

章意，就是优秀代表。

吉利学院专任教师，HG028B第一发起人。江苏省网络空间安全学会工业控制与工业互联网安全专委会会员，广西产学研科学研究院合作专家，IoT安全与人工智能安全研究者，具身智能安全研究者。

如今，王志鹏带出来的那批人已经形成了覆盖全国的技术网络——他们分布在主流车企、检测机构、安全厂商，彼此之间至今保持着紧密的联系。

一个是“黄埔军校校长”，一个是“黄埔”走出来的代表。多年后，他们坐在同一张茶台前，聊聊各自的路，也聊聊那段共同经历。

这次见面，我们就聊这些：

• 从“猫鼠游戏”到车联网安全——两个人的入行故事

• “车联网安全黄埔军校”是怎么炼成的？

• 那批人现在都在哪里？一个覆盖行业的技术网络如何形成？

• 从软安全到硬安全，再到具身智能——安全边界在如何扩展？

• 给后来者的建议：如何找到自己的引路人

没有PPT，没有商业推介，就是三个人，一壶茶，面对面，有一说一。

直播时间：8月16日（周日）下午 3:00
直播平台：微信视频号「HackingGroup」

预约通道已开启，点击预约

周日见。

-- 看雪学苑、嘶吼、Hacking Group · HG TALK

8月10日12:00，2026 KCTF攻防对抗赛正式开赛！本届赛事沿用多维度积分体系，难度、火力、精致度三重积分同步核算，攻防双向计分机制兼顾趣味性与竞技性。

*签到题《辰时·钟鸣破晓》赛事周期内持续开放，比赛全程都可以提交 flag 获取对应攻击积分。

我们带着这些问题和好奇

一起来看看本题的设计思路&解题思路

一起来看看本题的设计思路&解题思路

出题战队：one team

战队成员ID：穿甲葡萄籽

题目需要6个字符串，字符范围在小写大写数字中组成。成功后控制台会输出“恭喜成功！”，如果输出其他乱码字符或程序崩溃不算成功。

文件pyinstaller打包。将代码编写到os.py中，通过python源码编译把os.py编译到python.dll中。

用户可从python.dll中还原出os.py的代码。

根据提示的代码可获取到“print("恭喜成功！")”编译后的python字节马。

根据os.py中的分组异或代码可分析出异或的key。

x=0

whilex<20:

defmy_function():

print(666)

try:

x+=1

buffer=b''.join([

b'\xB3\xDA\xC5\xB2\xF1\xEF\xBA\xE9\xD9\xBC\xC9\xD5\xBD\xF3\xD4\xBD',

b'\xEA\xCD\xB0\xDB\xCA\xB2\xCF\xD1\xB1\xEE\xF6\xB2\xF5\xD4\x58\x5F',

b'\x31\x30\x33\x75\x38\x2C\x0A\x33\x20\x3B\x36\x21\x3C\x3A\x3B\x7D',

b'\x7C\x6F\x58\x5F\x5C\x25\x27\x3C\x3B\x21\x7D\x77\xB3\xD4\xF8\xB0',