首页
社区
课程
招聘
[原创]2025 HGAME WEEK1 RE WP
发表于: 2025-2-12 11:10 10669

[原创]2025 HGAME WEEK1 RE WP

2025-2-12 11:10
10669

过完年了也开学了,该玩的也都玩了,在盛大的欢乐之后就是无尽的空虚。收收心回归老本行,两周没有做题了还好宝刀未老,花了两天的时间ak了week1的逆向题目,个人不太满意,还是有点慢。

这道题意外的卡了很久,做的时候猜测是哈夫曼编码了,但是当时不太符合我心中的哈夫曼预期,后面专门看了下哈夫曼算法然后结合代码发现匹配,这才确定是。。。。忘的太快了,想当年也是408考119的男人。

题目很新颖,给的是nu脚本文件,还有个加密文件,通过理解脚本文件的加密逻辑,解密文件

这里因为我哈夫曼算法记忘了,在这里卡了很久,结合chatgpt和加入输出语句“调试”的情况下,得出是哈夫曼算法。

加密脚本由两部分组成,第一行为加密内容字符哈夫曼树,第二行则是根据第一行哈夫曼树的生成的字符转义。

写脚本求解:

之前做的题目都是找工具脱壳,第一次遇到手动脱壳的,也当练练手,好在不难

题目说明的暗示也给够了,也是一道考脱壳的题。脱壳之后的逻辑一目了然

放入DIE查一下壳,发现是UPX 3.91 modified,使用ida打开查看节区信息,发现是.add0, .add1等很奇怪的名字,也能猜个差不多是个魔改的加壳

接下来就是脱壳,不过我并没有发现可以使用esp定律定位oep的地方。不过我发现程序运行起来有个io,在程序等待输入的时候回到x64dbg中,发现代码已经脱壳完毕,此时正是一个很好的demp时机,使用插件一键dump,完成脱壳

将脱完壳的程序放入ida分析,程序很简单,两段rc4加密,写脚本求解:

这道题也很新,或者说,我没做过,完全就是现挂(看今年春晚学的词)

一道考察Delta的题目,通过应用Detla还原出文件,但是Detla的hash被修改了,需要找到正确的hash,才能还原flag。

求解本题的关键就是找到正确的hash,在寻找hash的时候废了很多时间,网上的文档也有限,最后无奈尝试土办法,在hash的内存起始处下入内存断点,然后成功在memcmp中定位到了真正的hash,我这是正确的解法吗??? 感觉我这样做出来有点简单。

恢复出来hash,后面的加密很简单,循环xor

写脚本求解:

这道也很有意思,题目也很新颖(我没做过)

给你一个apk,你就逆吧

这道题看了比较久,一直没找到关键逻辑,因为一开始我以为copyDexFromAssets是官方实现就没管,后面一看是藏东西了。现在长教训了,应当平等的怀疑每一个native函数

查看toast的反编译代码,

可以发现这里调用了 zunjia.dex 中的 encode函数

但是题目中的zunjia.dex 并没有encode函数,这让我不得不怀疑这是生成的新的dex,这个新的dex由encode函数。

写个脚本获取这个dex文件,使用frida hook:

这里我本意是保存到 /sdcard 下,但是程序以为权限问题崩溃没有保存到,但是塞翁失马焉知非福,程序崩溃,没有走到 file.delete(), 所以在cache dir下可以找到这个文件。

jadx 反编译下这个dex文件,逻辑一目了然,是个换表base64。

最后便是 check函数逻辑,在ida中找到注册check函数反向定位,恢复JNI 函数符号,逻辑很简单,就是个字符base64加密 作为rc4的密钥加密:

密钥长度为36位,写个程序枚举:

# 假设我们已经有了哈夫曼树
def decode_huffman_tree(huffman_tree, binary_path):
    flag = ""
    node = huffman_tree
    for bit in binary_path:
        if "s" in node:
            flag += chr(node['s'])
            node = huffman_tree
        if bit == '0':
            node = node['a']
        elif bit == '1':
            node = node['b']
    return flag
 
# 示例的路径和哈夫曼树(简化版本)
huffman_tree ={
    "a": {
        "a": {
            "a": {
                "a": {
                    "a": {
                        "s": 125
                    },
                    "b": {
                        "a": {
                            "s": 119
                        },
                        "b": {
                            "s": 123
                        }
                    }
                },
                "b": {
                    "a": {
                        "s": 104
                    },
                    "b": {
                        "s": 105
                    }
                }
            },
            "b": {
                "a": {
                    "s": 101
                },
                "b": {
                    "s": 103
                }
            }
        },
        "b": {
            "a": {
                "a": {
                    "a": {
                        "s": 10
                    },
                    "b": {
                        "s": 13
                    }
                },
                "b": {
                    "s": 32
                }
            },
            "b": {
                "a": {
                    "s": 115
                },
                "b": {
                    "s": 116
                }
            }
        }
    },
    "b": {
        "a": {
            "a": {
                "a": {
                    "a": {
                        "a": {
                            "s": 46
                        },
                        "b": {
                            "s": 48
                        }
                    },
                    "b": {
                        "a": {
                            "a": {
                                "s": 76
                            },
                            "b": {
                                "s": 78
                            }
                        },
                        "b": {
                            "a": {
                                "s": 83
                            },
                            "b": {
                                "a": {
                                    "s": 68
                                },
                                "b": {
                                    "s": 69
                                }
                            }
                        }
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 44
                        },
                        "b": {
                            "a": {
                                "s": 33
                            },
                            "b": {
                                "s": 38
                            }
                        }
                    },
                    "b": {
                        "s": 45
                    }
                }
            },
            "b": {
                "a": {
                    "a": {
                        "s": 100
                    },
                    "b": {
                        "a": {
                            "s": 98
                        },
                        "b": {
                            "s": 99
                        }
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 49
                        },
                        "b": {
                            "s": 51
                        }
                    },
                    "b": {
                        "s": 97
                    }
                }
            }
        },
        "b": {
            "a": {
                "a": {
                    "a": {
                        "s": 117
                    },
                    "b": {
                        "s": 118
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 112
                        },
                        "b": {
                            "s": 113
                        }
                    },
                    "b": {
                        "s": 114
                    }
                }
            },
            "b": {
                "a": {
                    "a": {
                        "s": 108
                    },
                    "b": {
                        "s": 109
                    }
                },
                "b": {
                    "a": {
                        "s": 110
                    },
                    "b": {
                        "s": 111
                    }
                }
            }
        }
    }
}
 
# 示例路径
binary_path = '00010001110111111010010000011100010111000100111000110000100010111001110010011011010101111011101100110100011101101001110111110111011011001110110011110011110110111011101101011001111011001111000111001101111000011001100001011011101100011100101001110010111001111000011000101001010000000100101000100010011111110110010111010101000111101000110110001110101011010011111111001111111011010101100001101110101101111110100100111100100010110101111111111100110001010101101110010011111000110110101101111010000011110100000110110101011000111111000110101001011100000110111100000010010100010001011100011100111001011101011111000101010110101111000001100111100011100101110101111100010110101110000010100000010110001111011100011101111110101010010011101011100100011110010010110111101110111010111110110001111010101110010001011100100101110001011010100001110101000101111010100110001110101011101100011011011000011010000001011000111011111111100010101011100000'  # 假设这是一个从根到叶子的路径
 
# 解码
decoded_char = decode_huffman_tree(huffman_tree, binary_path)
print(decoded_char)  # 输出 '}'
# 假设我们已经有了哈夫曼树
def decode_huffman_tree(huffman_tree, binary_path):
    flag = ""
    node = huffman_tree
    for bit in binary_path:
        if "s" in node:
            flag += chr(node['s'])
            node = huffman_tree
        if bit == '0':
            node = node['a']
        elif bit == '1':
            node = node['b']
    return flag
 
# 示例的路径和哈夫曼树(简化版本)
huffman_tree ={
    "a": {
        "a": {
            "a": {
                "a": {
                    "a": {
                        "s": 125
                    },
                    "b": {
                        "a": {
                            "s": 119
                        },
                        "b": {
                            "s": 123
                        }
                    }
                },
                "b": {
                    "a": {
                        "s": 104
                    },
                    "b": {
                        "s": 105
                    }
                }
            },
            "b": {
                "a": {
                    "s": 101
                },
                "b": {
                    "s": 103
                }
            }
        },
        "b": {
            "a": {
                "a": {
                    "a": {
                        "s": 10
                    },
                    "b": {
                        "s": 13
                    }
                },
                "b": {
                    "s": 32
                }
            },
            "b": {
                "a": {
                    "s": 115
                },
                "b": {
                    "s": 116
                }
            }
        }
    },
    "b": {
        "a": {
            "a": {
                "a": {
                    "a": {
                        "a": {
                            "s": 46
                        },
                        "b": {
                            "s": 48
                        }
                    },
                    "b": {
                        "a": {
                            "a": {
                                "s": 76
                            },
                            "b": {
                                "s": 78
                            }
                        },
                        "b": {
                            "a": {
                                "s": 83
                            },
                            "b": {
                                "a": {
                                    "s": 68
                                },
                                "b": {
                                    "s": 69
                                }
                            }
                        }
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 44
                        },
                        "b": {
                            "a": {
                                "s": 33
                            },
                            "b": {
                                "s": 38
                            }
                        }
                    },
                    "b": {
                        "s": 45
                    }
                }
            },
            "b": {
                "a": {
                    "a": {
                        "s": 100
                    },
                    "b": {
                        "a": {
                            "s": 98
                        },
                        "b": {
                            "s": 99
                        }
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 49
                        },
                        "b": {
                            "s": 51
                        }
                    },
                    "b": {
                        "s": 97
                    }
                }
            }
        },
        "b": {
            "a": {
                "a": {
                    "a": {
                        "s": 117
                    },
                    "b": {
                        "s": 118
                    }
                },
                "b": {
                    "a": {
                        "a": {
                            "s": 112
                        },
                        "b": {
                            "s": 113
                        }
                    },
                    "b": {
                        "s": 114
                    }
                }
            },
            "b": {
                "a": {
                    "a": {
                        "s": 108
                    },
                    "b": {
                        "s": 109
                    }
                },
                "b": {
                    "a": {
                        "s": 110
                    },
                    "b": {
                        "s": 111
                    }
                }
            }
        }
    }
}
 
# 示例路径
binary_path = '00010001110111111010010000011100010111000100111000110000100010111001110010011011010101111011101100110100011101101001110111110111011011001110110011110011110110111011101101011001111011001111000111001101111000011001100001011011101100011100101001110010111001111000011000101001010000000100101000100010011111110110010111010101000111101000110110001110101011010011111111001111111011010101100001101110101101111110100100111100100010110101111111111100110001010101101110010011111000110110101101111010000011110100000110110101011000111111000110101001011100000110111100000010010100010001011100011100111001011101011111000101010110101111000001100111100011100101110101111100010110101110000010100000010110001111011100011101111110101010010011101011100100011110010010110111101110111010111110110001111010101110010001011100100101110001011010100001110101000101111010100110001110101011101100011011011000011010000001011000111011111111100010101011100000'  # 假设这是一个从根到叶子的路径
 
# 解码
decoded_char = decode_huffman_tree(huffman_tree, binary_path)
print(decoded_char)  # 输出 '}'
from Crypto.Cipher.ARC4 import *
 
enc_key = bytes([
 0xCD,
 0x8F,
 0x25,
 0x3D,
 0xE1,
 ])
 
enc_key += b'QJ'
 
cipher = new(b'yekyek')
dec_key = cipher.decrypt(enc_key)
print(dec_key)
#ecg4ab6
 
enc_flag = [0 for i in range(40)]
v2 = enc_flag
v2[0] = 0xF8
v2[1] = -43
v2[2] = 98
v2[3] = -49
v2[4] = 67
v2[5] = -70
v2[6] = -62
v2[7] = 35
v2[8] = 21
v2[9] = 74
v2[10] = 81
v2[11] = 16
v2[12] = 39
v2[13] = 16
v2[14] = -79
v2[15] = -49
v2[16] = -60
v2[17] = 9
v2[18] = -2
v2[19] = -29
v2[20] = -97
v2[21] = 73
v2[22] = -121
v2[23] = -22
v2[24] = 89
v2[25] = -62
v2[26] = 7
v2[27] = 59
v2[28] = -87
v2[29] = 17
v2[30] = -63
v2[31] = -68
v2[32] = -3
v2[33] = 75
v2[34] = 87
v2[35] = -60
v2[36] = 126
v2[37] = -48
v2[38] = -86
v2[39] = 10
 
add_bytes = new(b'ecg4ab6').encrypt(b'\x00' * 40)
 
flag = ''
for i in range(40):
    flag += chr((enc_flag[i] + add_bytes[i]) & 0xff)
 
print(flag)
from Crypto.Cipher.ARC4 import *
 

[培训]科锐逆向工程师培训第53期2025年7月8日开班!

最后于 2025-2-12 11:20 被SleepAlone编辑 ,原因:
收藏
免费 0
支持
分享
最新回复 (3)
雪    币:
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
2
大佬,能讲解一下Delta Erro0000ors这道题的”最后无奈尝试土办法,在hash的内存起始处下入内存断点,然后成功在memcmp中定位到了真正的hash,我这是正确的解法吗??? 感觉我这样做出来有点简单。”这个方法吗?具体是如何实现的?这道题我当时动态调试了很久,好像一直会报异常而无法继续调试,没有做出来,想学习一下这个方法
2025-2-16 16:40
0
雪    币: 10
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
3
soapsama 大佬,能讲解一下Delta Erro0000ors这道题的”最后无奈尝试土办法,在hash的内存起始处下入内存断点,然后成功在memcmp中定位到了真正的hash,我这是正确的解法吗??? 感觉我这样 ...
你做出来了吗,我现在还没做出来,可以交流下吗
2025-2-20 21:22
0
雪    币: 4916
活跃值: (1840)
能力值: ( LV12,RANK:200 )
在线值:
发帖
回帖
粉丝
4
soapsama 大佬,能讲解一下Delta Erro0000ors这道题的”最后无奈尝试土办法,在hash的内存起始处下入内存断点,然后成功在memcmp中定位到了真正的hash,我这是正确的解法吗??? 感觉我这样 ...
就是在hash内存其实处下内存断点啊,然后程序断在memcmp里
2025-2-24 17:32
0
游客
登录 | 注册 方可回帖
返回