# Source Generated with Decompyle++
# File: re3.pyc (Python 2.7)

import string

# 自定义的 Base64 字符表：总共64个字符
c_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '()'

# 加密后的 flag（用于校验）
flag = 'BozjB3vlZ3ThBn9bZ2jhOH93ZaH9'

def encode(origin_bytes):
    # 将输入的每个字节转为8位二进制字符串
    c_bytes = [ '{:0>8}'.format(str(bin(b)).replace('0b', '')) for b in origin_bytes ]

    resp = ''  # 编码后的结果
    nums = len(c_bytes) // 3      # 能整除3的块数
    remain = len(c_bytes) % 3     # 剩下不足3个字节的数量

    # 取出可整除部分的所有字节（3的倍数部分）
    integral_part = c_bytes[0:3 * nums]

    # ❌ 以下部分是反编译错误，不合法：
    #   - tmp_unit 是空列表 []，无法索引
    #   - 逻辑本应是：将3字节拼接为24位，分4个6位，再映射为字符
    for x in [
        0,
        6,
        12,
        18]:
        tmp_unit = [][int(tmp_unit[x:x + 6], 2)]  # ❌ 无意义，非法访问空列表
        resp += ''.join([ c_charset[i] for i in tmp_unit ])
        integral_part = integral_part[3:]

    # 如果还有剩余的字节（1或2个），进行编码补齐
    if remain:
        # 将剩余的字节拼接起来，并补足到3字节（24位），补0
        remain_part = ''.join(c_bytes[3 * nums:]) + (3 - remain) * '0' * 8
        # 将24位分成4段，每段6位，然后只取前 remain+1 个字符
        tmp_unit = [ int(remain_part[x:x + 6], 2) for x in [
            0,
            6,
            12,
            18] ][:remain + 1]
        # 使用 c_charset 映射出字符，并在后面补 '.'（表示补齐）
        resp += ''.join([ c_charset[i] for i in tmp_unit ]) + (3 - remain) * '.'

    # 对编码结果再进行字符级加密（Caesar 加密）
    return rend(resp)

# 字符级加密函数：将字母右移2位（Caesar Cipher）
def rend(s):

    def encodeCh(ch):
        # Caesar 偏移函数：将 ch 转换为右移2位的字母
        f = lambda x: chr(((ord(ch) - x) + 2) % 26 + x)

        # 如果是小写字母，则从 'a' 偏移
        if ch.islower():
            return f(97)

        # ❌ 错误：这一句反编译错了，本意是 if ch.isupper()
        if (None,).isupper():  # ❌ 错误语法：元组对象没有 isupper() 方法
            return f(65)

    # ❌ 以下这句是非法语法，反编译错误
    #   - (''.join,) 是一个函数元组
    #   - (lambda .0: pass)(s) 是完全非法的表达式
    return (''.join,)((lambda .0: pass)(s))  # ❌ 无法执行

import string  
  
# 自定义 Base64 字符表：共 64 个字符（标准 Base64 是 A-Z a-z 0-9 + /，这里用 () 替代了 +/）  
c_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '()'  
# 即：'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789()'  
  
# 🔓 第一步：还原 Caesar Cipher 加密（字母左移 2 位）  
def unshift(s):  
    def shift_back(ch):  
        # 如果是小写字母  
        if ch.islower():  
            # 'a' 左移 2 应该变成 'y'，所以用 (ord(ch) - ord('a') - 2) % 26 做循环偏移  
            return chr((ord(ch) - ord('a') - 2) % 26 + ord('a'))  
        # 如果是大写字母  
        elif ch.isupper():  
            return chr((ord(ch) - ord('A') - 2) % 26 + ord('A'))  
        # 如果不是字母（如数字、括号等），原样返回  
        else:  
            return ch  
    # 把整个字符串的字符逐个还原 Caesar Cipher 加密  
    return ''.join(shift_back(c) for c in s)  
  
# 🔓 第二步：自定义 Base64 解码  
def custom_b64_decode(encoded):  
    # 去掉结尾可能的补位符号 '.'（源码中编码时为了对齐长度补了这个字符）  
    encoded = encoded.replace('.', '')  
  
    bin_str = ''  
  
    # 把每个字符变为其在 c_charset 中的索引，再转成 6 位的二进制字符串  
    for c in encoded:  
        index = c_charset.index(c)  
        bin_str += '{:06b}'.format(index)  
  
    # 每 8 位为一组，还原成原始的字节（byte）  
    bytes_out = []  
    for i in range(0, len(bin_str), 8):  
        byte = bin_str[i:i+8]  
        # 只有当长度足够 8 位，才转换（防止末尾被补零）  
        if len(byte) == 8:  
            bytes_out.append(int(byte, 2))  # 转换成十进制整数  
  
    # 返回字节数组组成的字节串（再 decode 还原为字符串）  
    return bytes(bytes_out)  
  
# 📦 已加密的 flag（由 encode() 函数生成）  
flag = 'BozjB3vlZ3ThBn9bZ2jhOH93ZaH9'  
  
# 第一步：对 Caesar 加密进行逆运算（右移2变成左移2）  
shifted = unshift(flag)  
print('[*] Caesar还原:', shifted)  
  
# 第二步：执行自定义 Base64 解码，还原原始明文 flagdecoded = custom_b64_decode(shifted)  
print('[+] 解密结果:', decoded)

def b58encode(tmp=None):
    # 将输入的字符串 tmp 转换为 ASCII 码列表
    tmp = list(map(ord, tmp))
    # 初始化 temp 为第一个字符的 ASCII 码
    temp = tmp[0]
    # Base58 字符集（去掉了容易混淆的 0, O, I, l 等字符）
    base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    
    # 将 tmp 视为大端序的字节序列，转换为一个大整数
    for i in range(len(tmp) - 1):
        temp = temp * 256 + tmp[i + 1]
    
    # 将大整数 temp 转换为 Base58 编码
    tmp = []
    while None:  # 反编译错误，应为 while temp > 0:
        temp = temp // 58
        if temp == 0:
            break
        # 反编译错误，应为 tmp.append(temp % 58)
        temp = ''
        for i in tmp:
            temp += base58[i]
    
    # 对 Base58 编码后的字符串逐字符进行异或操作（每个字符与其索引异或）
    tmp = []
    for i in range(len(temp)):
        tmp.append(chr(ord(temp[i]) ^ i))
    
    # 预定义的检查列表
    check = [
        'A', '5', 'q', 'O', 'g', 'q', 'd', '\x7f', '[', '\x7f', 's', '{',
        'G', 'A', 'x', '`', 'D', '@', 'K', 'c', '-', 'c', ' ', 'G', '+',
        '+', '|', 'x', '}', 'J', 'h', '\\', 'l']
    
    # 如果异或后的结果与 check 列表一致，返回 1
    if tmp == check:
        return 1

# 用户输入 flag
flag = input('输入flag：')
# 检查 flag 是否正确
if b58encode(flag):
    print('you win')
else:
    print('try again')

tmp = []
for i in range(len(temp)):
    tmp.append(chr(ord(temp[i]) ^ i))

# Base58 解码函数（将 Base58 字符串还原为原始字节序列）  
def b58decode(encoded):  
    base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'  
    temp = 0  
    # 将 Base58 字符串转换为一个整数  
    for c in encoded:  
        temp = temp * 58 + base58.index(c)  
  
    result = []  
    # 将整数逐个转为字节（8位）  
    while temp > 0:  
        result.insert(0, temp % 256)  # 插入到前面，保持原始顺序  
        temp //= 256  
  
    # 将字节列表转成字节串，再解码为字符串（假设原始输入是 ASCII/UTF-8 编码）  
    return bytes(result).decode()  
  
  
# 从原程序中的混淆字符列表提取出来  
check = [  
    'A', '5', 'q', 'O', 'g', 'q', 'd', '\x7f', '[', '\x7f', 's', '{', 'G', 'A',  
    'x', '`', 'D', '@', 'K', 'c', '-', 'c', ' ', 'G', '+', '+', '|', 'x', '}',  
    'J', 'h', '\\', 'l'  
]  
  
# 第一步：逆向异或操作，还原被混淆之前的 Base58 编码字符串  
# 原逻辑是：chr(ord(base58_char) ^ index)  
# 所以我们要反过来：base58_char = chr(ord(check_char) ^ index)  
encoded = ''.join([chr(ord(c) ^ i) for i, c in enumerate(check)])  
  
print("[*] 恢复出的 Base58 编码字符串:", encoded)  
  
# 第二步：Base58 解码，还原最初的用户输入 flagflag = b58decode(encoded)  
	  
print("[+] 恢复出的原始 flag:", flag)