求助Python转易语言

刚性兑付

class MessagePackDecoder:
    """MessagePack解码器的纯Python实现"""

    def __init__(self, data: bytes):
        self.data = data
        self.pos = 0
        self.length = len(data)

    def read_byte(self) -> int:
        if self.pos >= self.length:
            raise ValueError("Unexpected end of data")
        byte = self.data[self.pos]
        self.pos += 1
        return byte

    def read_bytes(self, count: int) -> bytes:
        if self.pos + count > self.length:
            raise ValueError("Unexpected end of data")
        result = self.data[self.pos:self.pos + count]
        self.pos += count
        return result

    def read_uint8(self) -> int:
        return self.read_byte()

    def read_uint16(self) -> int:
        return struct.unpack('>H', self.read_bytes(2))[0]

    def read_uint32(self) -> int:
        return struct.unpack('>I', self.read_bytes(4))[0]

    def read_uint64(self) -> int:
        return struct.unpack('>Q', self.read_bytes(8))[0]

    def read_int8(self) -> int:
        return struct.unpack('>b', self.read_bytes(1))[0]

    def read_int16(self) -> int:
        return struct.unpack('>h', self.read_bytes(2))[0]

    def read_int32(self) -> int:
        return struct.unpack('>i', self.read_bytes(4))[0]

    def read_int64(self) -> int:
        return struct.unpack('>q', self.read_bytes(8))[0]

    def read_float32(self) -> float:
        return struct.unpack('>f', self.read_bytes(4))[0]

    def read_float64(self) -> float:
        return struct.unpack('>d', self.read_bytes(8))[0]

    def read_string(self, length: int) -> str:
        return self.read_bytes(length).decode('utf-8')

    def decode_value(self) -> Any:
        """解码单个MessagePack值"""
        if self.pos >= self.length:
            raise ValueError("Unexpected end of data")

        format_byte = self.read_byte()

        # Positive fixint (0xxxxxxx)
        if format_byte <= 0x7f:
            return format_byte

        # Fixmap (1000xxxx)
        elif 0x80 <= format_byte <= 0x8f:
            size = format_byte & 0x0f
            return self.decode_map(size)

        # Fixarray (1001xxxx)
        elif 0x90 <= format_byte <= 0x9f:
            size = format_byte & 0x0f
            return self.decode_array(size)

        # Fixstr (101xxxxx)
        elif 0xa0 <= format_byte <= 0xbf:
            size = format_byte & 0x1f
            return self.read_string(size)

        # nil
        elif format_byte == 0xc0:
            return None

        # false
        elif format_byte == 0xc2:
            return False

        # true
        elif format_byte == 0xc3:
            return True

        # bin 8
        elif format_byte == 0xc4:
            size = self.read_uint8()
            return self.read_bytes(size)

        # bin 16
        elif format_byte == 0xc5:
            size = self.read_uint16()
            return self.read_bytes(size)

        # bin 32
        elif format_byte == 0xc6:
            size = self.read_uint32()
            return self.read_bytes(size)

        # float 32
        elif format_byte == 0xca:
            return self.read_float32()

        # float 64
        elif format_byte == 0xcb:
            return self.read_float64()

        # uint 8
        elif format_byte == 0xcc:
            return self.read_uint8()

        # uint 16
        elif format_byte == 0xcd:
            return self.read_uint16()

        # uint 32
        elif format_byte == 0xce:
            return self.read_uint32()

        # uint 64
        elif format_byte == 0xcf:
            return self.read_uint64()

        # int 8
        elif format_byte == 0xd0:
            return self.read_int8()

        # int 16
        elif format_byte == 0xd1:
            return self.read_int16()

        # int 32
        elif format_byte == 0xd2:
            return self.read_int32()

        # int 64
        elif format_byte == 0xd3:
            return self.read_int64()

        # str 8
        elif format_byte == 0xd9:
            size = self.read_uint8()
            return self.read_string(size)

        # str 16
        elif format_byte == 0xda:
            size = self.read_uint16()
            return self.read_string(size)

        # str 32
        elif format_byte == 0xdb:
            size = self.read_uint32()
            return self.read_string(size)

        # array 16
        elif format_byte == 0xdc:
            size = self.read_uint16()
            return self.decode_array(size)

        # array 32
        elif format_byte == 0xdd:
            size = self.read_uint32()
            return self.decode_array(size)

        # map 16
        elif format_byte == 0xde:
            size = self.read_uint16()
            return self.decode_map(size)

        # map 32
        elif format_byte == 0xdf:
            size = self.read_uint32()
            return self.decode_map(size)

        # Negative fixint (111xxxxx)
        elif format_byte >= 0xe0:
            return format_byte - 256  # Convert to signed

        else:
            raise ValueError(f"Unknown format byte: 0x{format_byte:02x}")

    def decode_array(self, size: int) -> List[Any]:
        """解码数组"""
        result = []
        for _ in range(size):
            result.append(self.decode_value())
        return result

    def decode_map(self, size: int) -> Dict[Any, Any]:
        """解码映射"""
        result = {}
        for _ in range(size):
            key = self.decode_value()
            value = self.decode_value()
            result[key] = value
        return result

    def decode(self) -> Any:
        """解码MessagePack数据"""
        try:
            return self.decode_value()
        except Exception as e:
            # 如果解码失败，返回原始数据的base64编码
            return base64.b64encode(self.data).decode('utf-8')


def decrypt(data: str) -> str:
    """解密函数的Python实现"""
    try:
        # 1. Base64解码
        # 清理非base64字符
        cleaned_data = ''.join(c for c in data if c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=')

        # 添加padding如果需要
        while len(cleaned_data) % 4 != 0:
            cleaned_data += '='

        try:
            decoded_bytes = base64.b64decode(cleaned_data)
        except Exception as e:
            # 如果base64解码失败，尝试其他方法
            return json.dumps({"error": f"Base64 decode failed: {str(e)}", "raw_data": data})

        # 2. 尝试MessagePack解码
        try:
            decoder = MessagePackDecoder(decoded_bytes)
            result = decoder.decode()

            # 3. 转换为JSON字符串
            def json_serializer(obj):
                """自定义JSON序列化器"""
                if isinstance(obj, bytes):
                    try:
                        return obj.decode('utf-8')
                    except:
                        return base64.b64encode(obj).decode('utf-8')
                elif hasattr(obj, '__dict__'):
                    return obj.__dict__
                else:
                    return str(obj)

            return json.dumps(result, ensure_ascii=False, default=json_serializer)

        except Exception as e:
            # 如果MessagePack解码失败，尝试直接解析为字符串
            try:
                text_result = decoded_bytes.decode('utf-8')
                return json.dumps({"text": text_result})
            except:
                # 最后的备选方案：返回十六进制表示
                hex_result = decoded_bytes.hex()
                return json.dumps({"hex": hex_result, "error": f"Decode failed: {str(e)}"})

    except Exception as e:
        return json.dumps({"error": f"Decrypt failed: {str(e)}", "raw_data": data})

houliyong123

.版本 2 .支持库 spec .支持库 dp1  .子程序 MessagePack解码器 .参数 data, 字节集 .局部变量 pos, 整数型 .局部变量 length, 整数型 .局部变量 result, 通用型  pos ＝ 1 length ＝ 取字节集长度 (data)  result ＝ 解码值 (data, pos, length) 返回 (result)  .子程序 解码值 .参数 data, 字节集 .参数 pos, 整数型, 参考 .参数 length, 整数型 .局部变量 format_byte, 字节型 .局部变量 size, 整数型 .局部变量 result, 通用型  .如果真 (pos ＞ length)     返回 ("数据意外结束") .如果真结束  format_byte ＝ 取字节集数据 (取字节集中间 (data, pos, 1), #字节型) pos ＝ pos ＋ 1  .判断开始 (format_byte ≤ 127)  ' 正固定整数     返回 (format_byte) .判断 (format_byte ≥ 224)  ' 负固定整数     返回 (format_byte － 256) .判断 (format_byte ＝ 192)  ' nil     返回 (空) .判断 (format_byte ＝ 194)  ' false     返回 (假) .判断 (format_byte ＝ 195)  ' true     返回 (真) .判断 (format_byte ＝ 202)  ' float32     返回 (取字节集数据 (取字节集中间 (data, pos, 4), #小数型)     pos ＝ pos ＋ 4 .判断 (format_byte ＝ 203)  ' float64     返回 (取字节集数据 (取字节集中间 (data, pos, 8), #双精度小数型)     pos ＝ pos ＋ 8 .判断 (format_byte ≥ 160 且 format_byte ≤ 191)  ' 固定字符串     size ＝ format_byte 位与 31     result ＝ 取字节集中间 (data, pos, size)     pos ＝ pos ＋ size     返回 (到文本 (result)) .判断 (format_byte ≥ 144 且 format_byte ≤ 159)  ' 固定数组     size ＝ format_byte 位与 15     返回 (解码数组 (data, pos, length, size)) .判断 (format_byte ≥ 128 且 format_byte ≤ 143)  ' 固定映射     size ＝ format_byte 位与 15     返回 (解码映射 (data, pos, length, size)) .默认     ' 其他类型处理...     返回 ("未知格式字节: " ＋ 取十六进制文本 (format_byte)) .判断结束  .子程序 解码数组 .参数 data, 字节集 .参数 pos, 整数型, 参考 .参数 length, 整数型 .参数 size, 整数型 .局部变量 result, 数组 .局部变量 i, 整数型 .局部变量 value, 通用型  重定义数组 (result, 假, size) .计次循环首 (size, i)     value ＝ 解码值 (data, pos, length)     加入成员 (result, value) .计次循环尾 () 返回 (result)  .子程序 解码映射 .参数 data, 字节集 .参数 pos, 整数型, 参考 .参数 length, 整数型 .参数 size, 整数型 .局部变量 result, 文本型 .局部变量 i, 整数型 .局部变量 key, 通用型 .局部变量 value, 通用型  result ＝ "{" .计次循环首 (size, i)     key ＝ 解码值 (data, pos, length)     value ＝ 解码值 (data, pos, length)     .如果 (i ＞ 1)         result ＝ result ＋ ","     .否则         result ＝ result ＋ ""     .如果结束     result ＝ result ＋ 到文本 (key) ＋ ":" ＋ 到文本 (value) .计次循环尾 () result ＝ result ＋ "}" 返回 (result)  .子程序 解密 .参数 data, 文本型 .局部变量 cleaned_data, 文本型 .局部变量 i, 整数型 .局部变量 c, 文本型 .局部变量 decoded_bytes, 字节集 .局部变量 result, 文本型  ' 1. 清理非base64字符 cleaned_data ＝ "" .计次循环首 (取文本长度 (data), i)     c ＝ 取文本中间 (data, i, 1)     .如果真 (寻找文本 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", c, , 假) ＞ 0)         cleaned_data ＝ cleaned_data ＋ c     .如果真结束 .计次循环尾 ()  ' 添加padding如果需要 .判断循环首 (取文本长度 (cleaned_data) ％ 4 ≠ 0)     cleaned_data ＝ cleaned_data ＋ "=" .判断循环尾 ()  ' 2. Base64解码 .如果真 (Base64解码 (cleaned_data, decoded_bytes) ＝ 假)     返回 (格式化文本 ("{\"error\":\"Base64解码失败\",\"raw_data\":\"%s\"}", data)) .如果真结束  ' 3. 尝试MessagePack解码 result ＝ MessagePack解码器 (decoded_bytes) .如果真 (是否为空 (result))     ' 尝试直接解析为字符串     .如果真 (是否文本型 (decoded_bytes))         返回 (格式化文本 ("{\"text\":\"%s\"}", 到文本 (decoded_bytes)))     .否则         返回 (格式化文本 ("{\"hex\":\"%s\",\"error\":\"解码失败\"}", 字节集_到十六进制 (decoded_bytes)))     .如果真结束 .如果真结束  返回 (result)

绿色的雨

将python写出为dll，供易调用即可

刚性兑付

绿色的雨 发表于 2025-7-10 09:12
将python写出为dll，供易调用即可

我已经写好了 dll调用 麻烦 而且拖家带口的