我又来了，这次用py的nuitka，我打包工具的另一个分支

1346

https://wwgw.lanzouu.com/ihNfH372ri3g
密码:6ku2来来来，这次没有上次的花样多，upx壳+nuitka，密码没有用明文保存，哈希值，爆破破解即可，能破解密码更强！，如果你能静态分析出伪代码最最强（猜的不算）！

yur0

🚀 启动实例 A
🔐 请输入密码：ow\& 4
✅ 验证成功！
📅 当前时间: 2025-09-27 20:52:50

import time

printable = [i for i in range(32, 127)]
MOD = 2**32
target = 1717711059
inv33 = pow(33, -1, MOD)
start = time.time()

pref_map = {}
count = 0

def djb2_from_bytes(bs):
    h = 5381
    for c in bs:
        h = ((h << 5) + h) ^ c
        h &= 0xFFFFFFFF
    return h

for a in printable:
    for b in printable:
        for c in printable:
            h = djb2_from_bytes(bytes([a, b, c]))
            pref_map[h] = bytes([a, b, c])
            count += 1

found = None
start2 = time.time()
iter_count = 0
for x in printable:
    for y in printable:
        for z in printable:
            prev1 = (inv33 * (target ^ z)) % MOD
            prev2 = (inv33 * (prev1 ^ y)) % MOD
            prev3 = (inv33 * (prev2 ^ x)) % MOD
            if prev3 in pref_map:
                found = pref_map[prev3] + bytes([x, y, z])
                print("Found:", found.decode())
                raise SystemExit
            iter_count += 1
            if iter_count % 2000000 == 0:
                print("iter", iter_count, "time", time.time() - start2)

神奇的人鱼

https://www.52pojie.cn/thread-2063208-1-1.html
非常好玩的题目 感谢楼主 这里给出解答思路

Rust

import sys
import base64
from datetime import datetime

_CIPHER = 'UkFMZ2leaGV6XjEzM+YRNidLR2ldaGV/XDEwMTAiUEROZm9fa2Z7'
_KEY = 'VEFPZ29fa2V5XzIwMjUh'
_STRINGS = ['🚀 启动实例 A\n', '🔐 请输入密码：', '✅ 验证成功！\n', '📅 当前时间: ']

OP_PUSH = 0x01
OP_LOAD_STR = 0x06
OP_CALL = 0x03
OP_JMP_IF_NE = 0x04
OP_HALT = 0x05

def _decrypt(data, k):
    return bytes(b ^ k[i % len(k)] for i, b in enumerate(data))

def _djb2(s):
    h = 5381
    for c in s:
        h = ((h << 5) + h) ^ c
    return h & 0xFFFFFFFF

class VM:
    def __init__(self, code):
        self.code = code
        self.pc = 0
        self.stack = []
        self.reg = [0, 0]
        self.handles = []

    def run(self):
        try:
            while self.pc < len(self.code):
                op = self.code[self.pc]
                self.pc += 1
                if op == OP_PUSH:
                    if self.pc + 4 > len(self.code):
                        break
                    v = int.from_bytes(self.code[self.pc:self.pc+4], 'little')
                    self.stack.append(v)
                    self.pc += 4
                elif op == OP_LOAD_STR:
                    if self.pc >= len(self.code):
                        break
                    self.reg[0] = self.code[self.pc]
                    self.pc += 1
                elif op == OP_CALL:
                    if self.pc >= len(self.code):
                        break
                    sc = self.code[self.pc]
                    self.pc += 1
                    if sc == 0:
                        print(_STRINGS[self.reg[0]], end='', flush=True)
                    elif sc == 1:
                        s = input().strip().encode()
                        self.handles.append(s)
                        self.reg[0] = len(self.handles) - 1
                    elif sc == 2:
                        code = self.stack.pop() if self.stack else 1
                    elif sc == 3:
                        h = self.reg[0]
                        self.reg[1] = _djb2(self.handles[h]) if 0 <= h < len(self.handles) else 0
                    elif sc == 4:
                        h = self.reg[0]
                        if 0 <= h < len(self.handles):
                            print(self.handles[h].decode('utf-8', 'replace'), flush=True)
                    elif sc == 5:
                        t = datetime.now().strftime("%Y-%m-%d %H:%M:%S").encode()
                        self.handles.append(t)
                        self.reg[0] = len(self.handles) - 1
                elif op == OP_JMP_IF_NE:
                    if self.pc >= len(self.code):
                        break
                    target = self.code[self.pc]
                    self.pc += 1
                    actual = self.reg[0]
                    expected = self.stack.pop() if self.stack else 0
                    if actual != expected:
                        if 0 <= target < len(self.code):
                            self.pc = target
                elif op == OP_HALT:
                    return
        except Exception as e:
            print(f"\n[VM ERROR] {e}", file=sys.stderr)


cipher = base64.b64decode(_CIPHER)
key = base64.b64decode(_KEY)
code = _decrypt(cipher, key)
VM(code).run()

if sys.platform == "win32":
    input("按回车键退出...")

楼主写的非常不错这个小型VM值得学习

pzl1988

还厉害的样子，！！~~~~

1346

Rust 发表于 2025-9-27 15:23
import sys
import base64
from datetime import datetime

可以可以，要是恢复背虚拟机保护的代码就更好

dizicheng

nuitka目前应该不能像pyinstaller一样破解获取源码吧？我不是说其他方法逆向

Rust

1346 发表于 2025-9-27 18:33
可以可以，要是恢复背虚拟机保护的代码就更好

后续懒得分析了不过你这个VM我要了

AiniWang

有没有nuitka的打包工具？可以提供一下吗

1346

Rust 发表于 2025-9-28 06:31
后续懒得分析了不过你这个VM我要了

这个虚拟机是生成最简化的版本了，控制流混淆和字节码混淆和垃圾指令都还没上，还在优化，制作过程遇到太多问题了，进度也不足，字节码支持的指令还很少

1346

yur0 发表于 2025-9-27 20:53
[md]
&#128640; 启动实例 A
&#128272; 请输入密码：ow\& 4

感谢分析，[DEBUG] 比较哈希: actual=193411124, expected=1717711059 (0x666230d3)

期望的哈希值 = 0x666230D3   您是真的厉害，DJB2 确实容易被哈希碰撞。大佬厉害