import base64
import bz2
import gzip
import lzma
import zlib
import tkinter as tk
from tkinter import ttk, scrolledtext, filedialog, messagebox
import os
import threading
import queue
import re
import ast
import chardet
from datetime import datetime
import keyword
class PythonDecoderApp:
def __init__(self, root):
self.root = root
self.root.title("Python代码解码工具")
self.root.geometry("1000x800")
self.root.minsize(800, 600)
# 设置主题和字体
self.setup_theme()
# 创建任务队列用于线程间通信
self.queue = queue.Queue()
self.running = True
# 创建主框架
self.main_frame = ttk.Frame(root, padding="10")
self.main_frame.pack(fill=tk.BOTH, expand=True)
# 创建输入区域
self.create_input_area()
# 创建选项区域
self.create_options_area()
# 创建输出区域 - 专注于Python代码显示
self.create_python_output_area()
# 创建状态栏
self.status_var = tk.StringVar()
self.status_var.set("就绪")
self.status_bar = ttk.Label(root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
# 存储解码结果的变量
self.raw_data = None
self.text_data = None
self.python_code = None
# 启动队列处理线程
self.root.after(100, self.process_queue)
# 窗口关闭处理
self.root.protocol("WM_DELETE_WINDOW", self.on_close)
def setup_theme(self):
"""设置界面主题"""
try:
self.style = ttk.Style()
# 尝试使用clam主题，如果不可用则使用默认主题
available_themes = self.style.theme_names()
if 'clam' in available_themes:
self.style.theme_use('clam')
# 配置样式
self.style.configure("TLabel", font=("Consolas", 10))
self.style.configure("TButton", font=("Consolas", 10))
self.style.configure("TCombobox", font=("Consolas", 10))
self.style.configure("Title.TLabel", font=("Consolas", 12, "bold"))
except Exception as e:
print(f"主题设置失败: {e}")
def create_input_area(self):
"""创建输入区域"""
input_frame = ttk.LabelFrame(self.main_frame, text="输入编码数据", padding="10")
input_frame.pack(fill=tk.X, pady=(0, 10))
# 输入格式说明
format_label = ttk.Label(input_frame,
text="支持Base64、Base16、Base32编码，支持bz2、gzip、lzma、zlib压缩格式",
foreground="blue")
format_label.pack(anchor=tk.W, pady=(0, 5))
# 输入文本框
self.input_text = scrolledtext.ScrolledText(input_frame, wrap=tk.WORD, height=8, font=("Consolas", 10))
self.input_text.pack(fill=tk.BOTH, expand=True, pady=(0, 5))
# 输入控制按钮
input_buttons = ttk.Frame(input_frame)
input_buttons.pack(fill=tk.X)
ttk.Button(input_buttons, text="从文件加载", command=self.load_from_file).pack(side=tk.LEFT, padx=5)
ttk.Button(input_buttons, text="清空输入", command=lambda: self.input_text.delete(1.0, tk.END)).pack(side=tk.RIGHT, padx=5)
ttk.Button(input_buttons, text="加载示例", command=self.load_example).pack(side=tk.LEFT, padx=5)
ttk.Button(input_buttons, text="验证Base64", command=self.validate_base64).pack(side=tk.LEFT, padx=5)
def create_options_area(self):
"""创建选项区域"""
options_frame = ttk.LabelFrame(self.main_frame, text="解码选项", padding="10")
options_frame.pack(fill=tk.X, pady=(0, 10))
# 第一行：解码模式
mode_frame = ttk.Frame(options_frame)
mode_frame.pack(fill=tk.X, pady=(0, 10))
ttk.Label(mode_frame, text="解码模式:").pack(side=tk.LEFT, padx=5)
self.mode_var = tk.StringVar(value="auto")
auto_radio = ttk.Radiobutton(mode_frame, text="自动检测 (推荐)", variable=self.mode_var, value="auto", command=self.toggle_method)
auto_radio.pack(side=tk.LEFT, padx=5)
manual_radio = ttk.Radiobutton(mode_frame, text="手动选择", variable=self.mode_var, value="manual", command=self.toggle_method)
manual_radio.pack(side=tk.LEFT, padx=5)
# 第二行：解码方法
method_frame = ttk.Frame(options_frame)
method_frame.pack(fill=tk.X, pady=(0, 10))
ttk.Label(method_frame, text="解码方法:").pack(side=tk.LEFT, padx=5)
self.method_var = tk.StringVar(value="base64")
self.method_combobox = ttk.Combobox(method_frame, textvariable=self.method_var, state="disabled",
values=["base64", "base16", "base32", "bz2", "gzip", "lzma", "zlib"])
self.method_combobox.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
# 第三行：高级选项
advanced_frame = ttk.Frame(options_frame)
advanced_frame.pack(fill=tk.X, pady=(0, 10))
# Python代码优化选项
self.python_detect_var = tk.BooleanVar(value=True)
ttk.Checkbutton(advanced_frame, text="自动检测并优化Python代码", variable=self.python_detect_var).pack(side=tk.LEFT, padx=5)
# 多层解码选项
self.multilayer_var = tk.BooleanVar(value=True)
ttk.Checkbutton(advanced_frame, text="启用多层解码", variable=self.multilayer_var).pack(side=tk.LEFT, padx=5)
# 语法高亮选项
self.syntax_highlight_var = tk.BooleanVar(value=True)
ttk.Checkbutton(advanced_frame, text="启用语法高亮", variable=self.syntax_highlight_var).pack(side=tk.LEFT, padx=5)
# 执行按钮
self.decode_button = ttk.Button(options_frame, text="执行解码", command=self.start_decoding)
self.decode_button.pack(fill=tk.X, pady=5)
def create_python_output_area(self):
"""创建专门用于显示Python代码的输出区域"""
# 主输出框架
output_frame = ttk.LabelFrame(self.main_frame, text="Python代码输出", padding="10")
output_frame.pack(fill=tk.BOTH, expand=True)
# 顶部信息栏
info_frame = ttk.Frame(output_frame)
info_frame.pack(fill=tk.X, pady=(0, 5))
# 结果标签
self.result_label = ttk.Label(info_frame, text="等待解码...")
self.result_label.pack(side=tk.LEFT, padx=5)
# 代码信息标签
self.code_info_label = ttk.Label(info_frame, text="", foreground="blue")
self.code_info_label.pack(side=tk.RIGHT, padx=5)
# 代码编辑区域 - 使用Text控件以便后续添加语法高亮
text_frame = ttk.Frame(output_frame)
text_frame.pack(fill=tk.BOTH, expand=True)
# 添加行号
self.line_numbers = tk.Text(text_frame, width=4, padx=5, pady=5, takefocus=0, border=0,
background='lightgray', state='disabled')
self.line_numbers.pack(side=tk.LEFT, fill=tk.Y)
# 代码显示区域
self.code_text = scrolledtext.ScrolledText(
text_frame,
wrap=tk.WORD,
font=("Consolas", 11),
undo=True,
maxundo=-1
)
self.code_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
# 配置标签用于语法高亮
self.code_text.tag_configure("keyword", foreground="blue", font=("Consolas", 11, "bold"))
self.code_text.tag_configure("string", foreground="green")
self.code_text.tag_configure("comment", foreground="gray")
self.code_text.tag_configure("function", foreground="purple")
self.code_text.tag_configure("class", foreground="darkblue", font=("Consolas", 11, "bold"))
self.code_text.tag_configure("number", foreground="red")
# 底部按钮栏
button_frame = ttk.Frame(output_frame)
button_frame.pack(fill=tk.X, pady=(5, 0))
# 左侧按钮组
left_buttons = ttk.Frame(button_frame)
left_buttons.pack(side=tk.LEFT)
ttk.Button(left_buttons, text="运行代码", command=self.run_code).pack(side=tk.LEFT, padx=5)
ttk.Button(left_buttons, text="保存为.py文件", command=self.save_python_file).pack(side=tk.LEFT, padx=5)
ttk.Button(left_buttons, text="复制代码", command=self.copy_code).pack(side=tk.LEFT, padx=5)
# 右侧按钮组
right_buttons = ttk.Frame(button_frame)
right_buttons.pack(side=tk.RIGHT)
ttk.Button(right_buttons, text="格式化代码", command=self.format_code).pack(side=tk.LEFT, padx=5)
ttk.Button(right_buttons, text="清空输出", command=self.clear_output).pack(side=tk.LEFT, padx=5)
def toggle_method(self):
"""切换解码模式"""
if self.mode_var.get() == "manual":
self.method_combobox.config(state="readonly")
else:
self.method_combobox.config(state="disabled")
def validate_base64(self):
"""验证Base64格式"""
input_data = self.input_text.get(1.0, tk.END).strip()
if not input_data:
messagebox.showwarning("警告", "请输入要验证的数据")
return
# 简单的Base64验证
try:
# 清理数据
cleaned = re.sub(r'[^A-Za-z0-9+/=]', '', input_data)
if len(cleaned) % 4 != 0:
cleaned += '=' * (4 - len(cleaned) % 4)
base64.b64decode(cleaned, validate=True)
messagebox.showinfo("验证结果", "Base64格式有效")
except Exception as e:
messagebox.showerror("验证结果", f"Base64格式无效: {str(e)}")
def load_example(self):
"""加载示例数据"""
# 创建一个Base64编码的Python代码示例
example_code = '''
import base64
import zlib
def hello_world():
"""一个简单的Hello World函数"""
print("Hello, World!")
return True
class ExampleClass:
"""示例类"""
def __init__(self, name):
self.name = name
def greet(self):
print(f"Hello, {self.name}!")
if __name__ == "__main__":
hello_world()
obj = ExampleClass("Python")
obj.greet()
'''
# 压缩并编码示例代码
compressed = zlib.compress(example_code.encode('utf-8'))
encoded = base64.b64encode(compressed).decode('utf-8')
self.input_text.delete(1.0, tk.END)
self.input_text.insert(tk.END, encoded)
self.status_var.set("已加载示例数据")
def load_from_file(self):
"""从文件加载数据"""
filename = filedialog.askopenfilename(
title="选择包含编码数据的文件",
filetypes=[("文本文件", "*.txt"), ("Python文件", "*.py"), ("所有文件", "*.*")]
)
if filename:
self.status_var.set(f"正在加载 {os.path.basename(filename)}...")
def load_file_thread():
try:
max_size = 10 * 1024 * 1024 # 10MB
file_size = os.path.getsize(filename)
if file_size > max_size:
self.queue.put(("show_error", f"文件过大（超过10MB），请选择较小的文件"))
return
# 尝试多种编码读取文件
encodings = ['utf-8', 'gbk', 'utf-16', 'latin-1']
content = None
for encoding in encodings:
try:
with open(filename, 'r', encoding=encoding) as f:
content = f.read()
break
except UnicodeDecodeError:
continue
if content is None:
# 如果文本编码都失败，尝试二进制读取
with open(filename, 'rb') as f:
binary_data = f.read()
detected = chardet.detect(binary_data)
encoding = detected.get('encoding', 'utf-8')
try:
content = binary_data.decode(encoding)
except:
content = binary_data.decode('utf-8', errors='ignore')
self.queue.put(("update_status", f"已从 {os.path.basename(filename)} 加载数据"))
self.root.after(0, lambda: self.update_input_text(content, filename))
except Exception as e:
self.queue.put(("show_error", f"加载文件失败: {str(e)}"))
self.queue.put(("update_status", "文件加载失败"))
threading.Thread(target=load_file_thread, daemon=True).start()
def update_input_text(self, content, filename):
"""更新输入文本框"""
self.input_text.delete(1.0, tk.END)
self.input_text.insert(tk.END, content)
self.status_var.set(f"已从 {os.path.basename(filename)} 加载数据")
def clear_output(self):
"""清空输出区域"""
self.code_text.config(state=tk.NORMAL)
self.code_text.delete(1.0, tk.END)
self.code_text.config(state=tk.DISABLED)
self.result_label.config(text="等待解码...")
self.code_info_label.config(text="")
self.update_line_numbers()
self.raw_data = None
self.text_data = None
self.python_code = None
self.status_var.set("输出已清空")
def update_line_numbers(self):
"""更新行号显示"""
self.line_numbers.config(state=tk.NORMAL)
self.line_numbers.delete(1.0, tk.END)
# 获取代码行数
code_content = self.code_text.get(1.0, tk.END)
line_count = code_content.count('\n')
# 添加行号
if line_count > 0:
line_numbers_text = '\n'.join(str(i) for i in range(1, line_count + 1))
self.line_numbers.insert(1.0, line_numbers_text)
self.line_numbers.config(state=tk.DISABLED')
def apply_syntax_highlighting(self):
"""应用Python语法高亮"""
if not self.syntax_highlight_var.get():
return
# 清除所有现有标签
for tag in self.code_text.tag_names():
if tag != "sel": # 保留选择标签
self.code_text.tag_remove(tag, "1.0", tk.END)
# 获取代码内容
code_content = self.code_text.get(1.0, tk.END)
# Python关键字
python_keywords = keyword.kwlist + ['print', 'len', 'range', 'type', 'str', 'int', 'float', 'list', 'dict', 'tuple', 'set']
# 高亮关键字
for kw in python_keywords:
start_idx = "1.0"
while True:
start_idx = self.code_text.search(r'\b' + re.escape(kw) + r'\b', start_idx, stopindex=tk.END, regexp=True)
if not start_idx:
break
end_idx = f"{start_idx}+{len(kw)}c"
self.code_text.tag_add("keyword", start_idx, end_idx)
start_idx = end_idx
# 高亮字符串
self.highlight_pattern(r'(\"\"\"|\'\'\'|\"|\')(.*?)(\"\"\"|\'\'\'|\"|\')', "string")
# 高亮注释
self.highlight_pattern(r'#.*$', "comment", regexp=True)
# 高亮函数定义
self.highlight_pattern(r'def\s+(\w+)\s*\(', "function", regexp=True, group=1)
# 高亮类定义
self.highlight_pattern(r'class\s+(\w+)\s*\(?', "class", regexp=True, group=1)
# 高亮数字
self.highlight_pattern(r'\b\d+\b', "number", regexp=True)
def highlight_pattern(self, pattern, tag, regexp=False, group=0):
"""高亮匹配模式的文本"""
start_idx = "1.0"
while True:
if regexp:
start_idx = self.code_text.search(pattern, start_idx, stopindex=tk.END, regexp=True)
else:
start_idx = self.code_text.search(pattern, start_idx, stopindex=tk.END)
if not start_idx:
break
if group > 0:
# 获取匹配的文本内容
match_start = self.code_text.index(start_idx)
content = self.code_text.get(start_idx, f"{start_idx}+100c")
match_obj = re.search(pattern, content)
if match_obj and len(match_obj.groups()) >= group:
matched_text = match_obj.group(group)
end_idx = f"{start_idx}+{len(matched_text)}c"
self.code_text.tag_add(tag, start_idx, end_idx)
start_idx = end_idx
else:
start_idx = f"{start_idx}+1c"
else:
end_idx = self.code_text.index(f"{start_idx}+{len(pattern)}c")
self.code_text.tag_add(tag, start_idx, end_idx)
start_idx = end_idx
def copy_code(self):
"""复制代码到剪贴板"""
try:
self.code_text.config(state=tk.NORMAL)
content = self.code_text.get(1.0, tk.END).strip()
self.code_text.config(state=tk.DISABLED)
if content:
self.root.clipboard_clear()
self.root.clipboard_append(content)
self.status_var.set("代码已复制到剪贴板")
else:
messagebox.showwarning("警告", "没有代码可复制")
except Exception as e:
messagebox.showerror("错误", f"复制失败: {str(e)}")
def save_python_file(self):
"""保存Python代码到文件"""
if not self.python_code and not self.text_data:
messagebox.showwarning("警告", "没有可保存的Python代码，请先执行解码")
return
filename = filedialog.asksaveasfilename(
title="保存Python代码",
defaultextension=".py",
filetypes=[("Python文件", "*.py"), ("所有文件", "*.*")]
)
if filename:
def save_thread():
try:
content = self.python_code if self.python_code else self.text_data
with open(filename, 'w', encoding='utf-8') as f:
f.write(content)
self.queue.put(("update_status", f"Python代码已保存到 {os.path.basename(filename)}"))
self.queue.put(("show_info", f"Python代码已保存到 {filename}"))
except Exception as e:
self.queue.put(("show_error", f"保存文件失败: {str(e)}"))
self.queue.put(("update_status", "保存文件失败"))
threading.Thread(target=save_thread, daemon=True).start()
def format_code(self):
"""格式化Python代码"""
if not self.python_code and not self.text_data:
messagebox.showwarning("警告", "没有可格式化的代码")
return
try:
# 简单的代码格式化 - 调整缩进和空格
code = self.python_code if self.python_code else self.text_data
# 分割行并处理缩进
lines = code.split('\n')
formatted_lines = []
indent_level = 0
for line in lines:
stripped = line.strip()
if not stripped: # 空行
formatted_lines.append('')
continue
# 减少缩进级别（如果行以这些关键字结尾）
if stripped.startswith(('return', 'break', 'continue', 'pass')):
indent_level = max(0, indent_level - 1)
# 添加当前缩进
formatted_line = ' ' * indent_level + stripped
formatted_lines.append(formatted_line)
# 增加缩进级别（如果行以这些关键字结尾）
if stripped.endswith((':', ':\\')) and not stripped.startswith('#'):
indent_level += 1
formatted_code = '\n'.join(formatted_lines)
# 更新显示
self.code_text.config(state=tk.NORMAL)
self.code_text.delete(1.0, tk.END)
self.code_text.insert(tk.END, formatted_code)
self.code_text.config(state=tk.DISABLED)
self.update_line_numbers()
self.apply_syntax_highlighting()
self.status_var.set("代码已格式化")
except Exception as e:
messagebox.showerror("错误", f"格式化代码失败: {str(e)}")
def run_code(self):
"""尝试运行Python代码（在安全环境中）"""
if not self.python_code and not self.text_data:
messagebox.showwarning("警告", "没有可运行的代码")
return
code = self.python_code if self.python_code else self.text_data
# 安全检查 - 禁止危险操作
dangerous_patterns = [
r'__import__\s*\(', r'eval\s*\(', r'exec\s*\(', r'compile\s*\(',
r'open\s*\(', r'file\s*\(', r'os\.', r'sys\.', r'subprocess\.',
r'import\s+os', r'import\s+sys', r'import\s+subprocess'
]
for pattern in dangerous_patterns:
if re.search(pattern, code, re.IGNORECASE):
messagebox.showerror("安全警告", "代码包含可能危险的操作，无法在沙箱中运行")
return
# 在对话框中显示执行结果
try:
# 创建新窗口显示执行结果
result_window = tk.Toplevel(self.root)
result_window.title("代码执行结果")
result_window.geometry("600x400")
result_window.transient(self.root)
result_window.grab_set()
# 创建输出区域
output_text = scrolledtext.ScrolledText(result_window, wrap=tk.WORD, font=("Consolas", 10))
output_text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# 重定向输出
import io
import sys
from contextlib import redirect_stdout, redirect_stderr
old_stdout = sys.stdout
old_stderr = sys.stderr
output_buffer = io.StringIO()
try:
sys.stdout = output_buffer
sys.stderr = output_buffer
# 执行代码
exec(code)
# 恢复标准输出
sys.stdout = old_stdout
sys.stderr = old_stderr
# 显示结果
output_text.insert(tk.END, output_buffer.getvalue())
if not output_buffer.getvalue():
output_text.insert(tk.END, "代码执行完成，无输出")
output_text.config(state=tk.DISABLED)
except Exception as e:
# 恢复标准输出
sys.stdout = old_stdout
sys.stderr = old_stderr
output_text.insert(tk.END, f"执行错误: {str(e)}")
output_text.config(state=tk.DISABLED)
except Exception as e:
messagebox.showerror("错误", f"无法执行代码: {str(e)}")
# Python代码检测与优化
def is_python_code(self, text):
"""检测文本是否为Python代码"""
if not text or not text.strip():
return False
# 先尝试使用AST解析验证语法
try:
# 移除可能的编码声明和特殊字符
cleaned_text = re.sub(r'^#.*coding[:=]\s*[\w-]+', '', text, flags=re.IGNORECASE)
cleaned_text = re.sub(r'[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]', '', cleaned_text)
# 尝试解析为Python AST
ast.parse(cleaned_text)
return True
except SyntaxError:
# 如果AST解析失败，使用特征模式匹配
pass
# Python特征模式
python_patterns = [
r'^import\s+\w+', # 导入语句
r'^from\s+\w+\s+import', # 从模块导入
r'^def\s+\w+\s*\(', # 函数定义
r'^class\s+\w+', # 类定义
r'^\s*if\s+.*?:', # if语句
r'^\s*for\s+.*?:', # for循环
r'^\s*while\s+.*?:', # while循环
r'print\s*\(', # print函数
r'^\s*#', # 注释
]
# 检查是否有多个Python特征
matches = 0
lines = text.split('\n')[:20] # 检查前20行
for line in lines:
for pattern in python_patterns:
if re.search(pattern, line.strip(), re.IGNORECASE):
matches += 1
break
return matches >= 3 # 至少匹配3个模式
def clean_python_code(self, text):
"""清理和优化Python代码显示"""
if not text:
return text
# 移除可能的控制字符
cleaned = re.sub(r'[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]', '', text)
# 修复常见的编码问题
lines = cleaned.split('\n')
cleaned_lines = []
for line in lines:
# 移除行首行尾的异常空白字符
cleaned_line = line.rstrip()
if cleaned_line:
cleaned_lines.append(cleaned_line)
result = '\n'.join(cleaned_lines)
# 尝试规范化缩进
try:
# 检测缩进类型
spaces = sum(1 for c in result if c == ' ')
tabs = sum(1 for c in result if c == '\t')
if tabs > spaces and spaces > 0:
# 混合缩进，转换为空格
result = result.replace('\t', ' ')
elif spaces > tabs and tabs > 0:
# 混合缩进，转换为制表符
result = re.sub(r' ', '\t', result)
except:
pass # 如果处理失败，保持原样
return result
# 解码功能实现
def clean_input_data(self, data):
"""清理输入数据，移除可能的非编码字符"""
if isinstance(data, str):
# 移除空格、换行等可能干扰解码的字符
cleaned = re.sub(r'[^A-Za-z0-9+/=]', '', data)
return cleaned
return data
def decode_base64(self, encoded_data):
"""Base64解码"""
try:
# 确保输入是字节类型
if isinstance(encoded_data, str):
encoded_data = encoded_data.encode('utf-8')
# 添加必要的填充
padding = 4 - len(encoded_data) % 4
if padding != 4:
encoded_data += b'=' * padding
result = base64.b64decode(encoded_data, validate=True)
return result, "Base64解码成功"
except Exception as e:
return None, f"Base64解码失败: {str(e)}"
def decode_base16(self, encoded_data):
"""Base16解码"""
try:
if isinstance(encoded_data, str):
encoded_data = encoded_data.encode('utf-8')
result = base64.b16decode(encoded_data, casefold=True)
return result, "Base16解码成功"
except Exception as e:
return None, f"Base16解码失败: {str(e)}"
def decode_base32(self, encoded_data):
"""Base32解码"""
try:
if isinstance(encoded_data, str):
encoded_data = encoded_data.encode('utf-8')
result = base64.b32decode(encoded_data, casefold=True)
return result, "Base32解码成功"
except Exception as e:
return None, f"Base32解码失败: {str(e)}"
def decompress_bz2(self, data):
"""bz2解压缩"""
try:
return bz2.decompress(data), "bz2解压缩成功"
except Exception as e:
return None, f"bz2解压缩失败: {str(e)}"
def decompress_gzip(self, data):
"""gzip解压缩"""
try:
return gzip.decompress(data), "gzip解压缩成功"
except Exception as e:
return None, f"gzip解压缩失败: {str(e)}"
def decompress_lzma(self, data):
"""lzma解压缩"""
try:
return lzma.decompress(data), "lzma解压缩成功"
except Exception as e:
return None, f"lzma解压缩失败: {str(e)}"
def decompress_zlib(self, data):
"""zlib解压缩"""
try:
return zlib.decompress(data), "zlib解压缩成功"
except Exception as e:
return None, f"zlib解压缩失败: {str(e)}"
def decode_text(self, data):
"""将二进制数据解码为文本"""
# 优先尝试Python常用编码
encodings = ['utf-8', 'gbk', 'utf-16', 'latin-1', 'gb2312', 'ascii']
for encoding in encodings:
try:
return data.decode(encoding), f"使用{encoding}编码解析成功"
except UnicodeDecodeError:
continue
# 使用chardet检测编码
try:
detected = chardet.detect(data)
encoding = detected.get('encoding', 'utf-8')
confidence = detected.get('confidence', 0)
if confidence > 0.5: # 置信度大于50%
try:
return data.decode(encoding), f"使用检测到的{encoding}编码解析成功(置信度:{confidence:.2f})"
except UnicodeDecodeError:
pass
except:
pass
# 最后尝试忽略错误解码
try:
return data.decode('utf-8', errors='ignore'), "使用utf-8编码解析(忽略错误)"
except:
return None, "无法解析为文本"
def multilayer_decode(self, data, max_depth=5):
"""多层解码，递归解压缩直到无法继续"""
if max_depth <= 0:
return data, "达到最大递归深度"
current_data = data
decode_log = []
# 尝试各种解压缩方法
decompressors = [
("bz2", self.decompress_bz2),
("gzip", self.decompress_gzip),
("lzma", self.decompress_lzma),
("zlib", self.decompress_zlib)
]
for name, decompressor in decompressors:
result, msg = decompressor(current_data)
if result:
decode_log.append(f"第{6-max_depth}层: {msg}")
# 递归尝试进一步解压缩
deeper_result, deeper_log = self.multilayer_decode(result, max_depth-1)
if deeper_result != result: # 如果进一步解压缩成功
decode_log.extend(deeper_log)
return deeper_result, decode_log
else:
return result, decode_log
return current_data, decode_log
def auto_decode(self, encoded_data):
"""自动解码流程"""
# 1. 清理输入数据
cleaned_data = self.clean_input_data(encoded_data)
# 2. 尝试各种编码解码
decoders = [
("base64", self.decode_base64),
("base16", self.decode_base16),
("base32", self.decode_base32)
]
decoded_data = None
decode_log = []
for name, decoder in decoders:
result, msg = decoder(cleaned_data)
if result:
decoded_data = result
decode_log.append(f"{msg}")
break
if not decoded_data:
return None, "无法使用任何编码格式解码输入数据"
# 3. 多层解压缩（如果启用）
if self.multilayer_var.get():
final_data, decompress_log = self.multilayer_decode(decoded_data)
decode_log.extend(decompress_log)
else:
final_data = decoded_data
# 4. 尝试解析为文本
text, text_msg = self.decode_text(final_data)
decode_log.append(text_msg)
if text:
return (final_data, text), "; ".join(decode_log)
return (final_data, None), "; ".join(decode_log)
def manual_decode(self, encoded_data, method):
"""手动选择解码方法"""
# 清理输入数据
cleaned_data = self.clean_input_data(encoded_data)
if method in ["base64", "base16", "base32"]:
# 编码解码
if method == "base64":
result, msg = self.decode_base64(cleaned_data)
elif method == "base16":
result, msg = self.decode_base16(cleaned_data)
elif method == "base32":
result, msg = self.decode_base32(cleaned_data)
if not result:
return None, f"解码失败: {msg}"
# 尝试解压缩（如果看起来是压缩数据）
if len(result) > 0:
# 检查是否是压缩格式
decompressors = [
("bz2", self.decompress_bz2),
("gzip", self.decompress_gzip),
("lzma", self.decompress_lzma),
("zlib", self.decompress_zlib)
]
for name, decompressor in decompressors:
decompressed, decompress_msg = decompressor(result)
if decompressed:
result = decompressed
msg += f"; {decompress_msg}"
break
text, text_msg = self.decode_text(result)
return (result, text), f"{msg}; {text_msg}"
else:
# 先进行Base64解码，然后解压缩
decoded_b64, msg = self.decode_base64(cleaned_data)
if not decoded_b64:
return None, f"解码失败: {msg}"
if method == "bz2":
result, decompress_msg = self.decompress_bz2(decoded_b64)
elif method == "gzip":
result, decompress_msg = self.decompress_gzip(decoded_b64)
elif method == "lzma":
result, decompress_msg = self.decompress_lzma(decoded_b64)
elif method == "zlib":
result, decompress_msg = self.decompress_zlib(decoded_b64)
else:
return None, "无效的解码方法"
if not result:
return None, f"解码失败: {decompress_msg}"
text, text_msg = self.decode_text(result)
return (result, text), f"{msg}; {decompress_msg}; {text_msg}"
def update_code_info(self, code):
"""更新代码信息"""
if not code:
self.code_info_label.config(text="")
return
lines = code.split('\n')
line_count = len(lines)
char_count = len(code)
# 统计Python元素
function_count = len(re.findall(r'def\s+\w+\s*\(', code))
class_count = len(re.findall(r'class\s+\w+', code))
import_count = len(re.findall(r'import\s+\w+', code)) + len(re.findall(r'from\s+\w+\s+import', code))
info_text = f"行数: {line_count} | 字符: {char_count}"
if function_count > 0:
info_text += f" | 函数: {function_count}"
if class_count > 0:
info_text += f" | 类: {class_count}"
if import_count > 0:
info_text += f" | 导入: {import_count}"
self.code_info_label.config(text=info_text)
def process_queue(self):
"""处理后台线程发送到UI线程的任务"""
while not self.queue.empty():
try:
task = self.queue.get_nowait()
task_type = task[0]
if task_type == "update_status":
self.status_var.set(task[1])
elif task_type == "update_result":
self.result_label.config(text=task[1])
self.status_var.set("解码完成")
elif task_type == "display_output":
self.code_text.config(state=tk.NORMAL)
self.code_text.delete(1.0, tk.END)
self.code_text.insert(tk.END, task[1])
self.code_text.config(state=tk.DISABLED)
self.update_line_numbers()
self.apply_syntax_highlighting()
self.update_code_info(task[1])
elif task_type == "show_error":
messagebox.showerror("错误", task[1])
elif task_type == "show_info":
messagebox.showinfo("提示", task[1])
except Exception as e:
print(f"处理队列任务出错: {e}")
if self.running:
self.root.after(100, self.process_queue)
def start_decoding(self):
"""开始解码过程"""
self.decode_button.config(state=tk.DISABLED)
self.clear_output()
input_data = self.input_text.get(1.0, tk.END).strip()
if not input_data:
messagebox.showwarning("警告", "请输入编码数据")
self.decode_button.config(state=tk.NORMAL)
return
def decode_thread():
try:
self.queue.put(("update_status", "正在解码..."))
if self.mode_var.get() == "auto":
result, msg = self.auto_decode(input_data)
else:
method = self.method_var.get()
result, msg = self.manual_decode(input_data, method)
if result:
self.raw_data, self.text_data = result
self.python_code = None
# 检测并优化Python代码
if self.text_data and self.python_detect_var.get():
if self.is_python_code(self.text_data):
self.python_code = self.clean_python_code(self.text_data)
msg += "; 检测到Python代码并已优化显示"
else:
msg += "; 未检测到Python代码特征"
# 准备显示内容
display_text = ""
if self.python_code:
display_text = self.python_code
elif self.text_data:
if len(self.text_data) > 100000:
display_text = self.text_data[:100000] + "\n\n...内容过长，已截断显示..."
else:
display_text = self.text_data
else:
display_text = f"# 二进制数据（{len(self.raw_data)}字节）\n"
display_text += "# 无法解析为Python代码\n"
display_text += f"# 前100字节（十六进制）:\n# "
display_text += ' '.join(f'{b:02x}' for b in self.raw_data[:100])
self.queue.put(("update_result", msg))
self.queue.put(("display_output", display_text))
else:
self.queue.put(("show_error", msg))
self.queue.put(("update_status", "解码失败"))
except Exception as e:
error_msg = f"解码过程中发生错误: {str(e)}"
self.queue.put(("show_error", error_msg))
self.queue.put(("update_status", "解码过程中发生错误"))
finally:
self.root.after(0, lambda: self.decode_button.config(state=tk.NORMAL))
threading.Thread(target=decode_thread, daemon=True).start()
if __name__ == "__main__":
root = tk.Tk()
app = PythonDecoderApp(root)
root.mainloop()修改错误
灰码与二进制码转换详解
本文详细讲解了如何将灰码(graycode)转换为二进制码(binarycode)，通过具体的模块代码示例，阐述了转换过程中的关键步骤与逻辑运算。对于对编码转换感兴趣或需要了解灰码与二进制码转换原理的技术人员来说，本文提供了实用的参考与讨论。
扫一扫
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
