学爬虫在内网机器很多东西无法从互联网获取内容，所以借助ai写了一个基于本地的工具

调味包

在内网机器很多东西无法从互联网获取内容，所以借助ai写了一个基于本地的工具，借助自己偷懒节省时间

界面Pyqt6   我感觉TK有点单调！





下载链接
https://www.123912.com/s/1XvlVv-YA5QA?提取码:52pj

[Python] 纯文本查看 复制代码

import sys
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                           QHBoxLayout, QTabWidget, QTextEdit, QPushButton, QLabel,
                           QSplitter, QFrame)
from PyQt6.QtCore import Qt
from PyQt6.QtGui import QIcon, QFont
import json
import base64
from datetime import datetime
from urllib.parse import urlparse, parse_qs, quote, unquote
from bs4 import BeautifulSoup
import jsbeautifier
import difflib
import hashlib
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

class FormatTool(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('爬虫基础工具-本地化')
        self.setGeometry(100, 100, 1200, 800)
        
        # 设置应用样式
        self.setStyleSheet("""
            QMainWindow {
                background-color: #f0f0f0;
            }
            QTabWidget::pane {
                border: 1px solid #cccccc;
                background: white;
                border-radius: 4px;
            }
            QTabWidget::tab-bar {
                left: 5px;
            }
            QTabBar::tab {
                background: #e1e1e1;
                border: 1px solid #cccccc;
                padding: 8px 12px;
                margin-right: 2px;
                border-top-left-radius: 4px;
                border-top-right-radius: 4px;
            }
            QTabBar::tab:selected {
                background: white;
                border-bottom-color: white;
            }
            QPushButton {
                background-color: #2196F3;
                color: white;
                border: none;
                padding: 8px 16px;
                border-radius: 4px;
                min-width: 100px;
            }
            QPushButton:hover {
                background-color: #1976D2;
            }
            QPushButton:pressed {
                background-color: #0D47A1;
            }
            QTextEdit {
                border: 1px solid #cccccc;
                border-radius: 4px;
                padding: 5px;
                background-color: white;
                font-family: "Consolas", "Monaco", monospace;
                font-size: 12px;
            }
            QLabel {
                color: #333333;
                font-weight: bold;
                margin-bottom: 5px;
            }
        """)
        
        # 创建中心部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建主布局
        layout = QVBoxLayout(central_widget)
        layout.setContentsMargins(10, 10, 10, 10)
        layout.setSpacing(10)
        
        # 创建标签页
        tabs = QTabWidget()
        tabs.setDocumentMode(True)  # 使用更现代的外观
        layout.addWidget(tabs)
        
        # 添加各个功能标签页
        tabs.addTab(self.create_json_tab(), 'JSON工具')
        tabs.addTab(self.create_url_tab(), 'URL工具')
        tabs.addTab(self.create_format_tab(), '格式化工具')
        tabs.addTab(self.create_encode_tab(), '编码解码')
        tabs.addTab(self.create_compare_tab(), '对比工具')
        tabs.addTab(self.create_crypto_tab(), '加密工具')

    def create_text_edit(self):
        """创建统一样式的文本编辑器"""
        text_edit = QTextEdit()
        text_edit.setMinimumHeight(200)
        return text_edit

    def create_button(self, text):
        """创建统一样式的按钮"""
        button = QPushButton(text)
        button.setFont(QFont('Arial', 10))
        return button

    def create_json_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # 使用QSplitter来分割输入和输出区域
        splitter = QSplitter(Qt.Orientation.Vertical)
        
        # 输入区
        input_widget = QWidget()
        input_layout = QVBoxLayout(input_widget)
        input_label = QLabel('输入JSON:')
        input_text = self.create_text_edit()
        input_layout.addWidget(input_label)
        input_layout.addWidget(input_text)
        
        # 按钮区
        btn_layout = QHBoxLayout()
        format_btn = self.create_button('格式化')
        validate_btn = self.create_button('验证')
        to_sql_btn = self.create_button('转SQL')
        btn_layout.addWidget(format_btn)
        btn_layout.addWidget(validate_btn)
        btn_layout.addWidget(to_sql_btn)
        btn_layout.addStretch()
        input_layout.addLayout(btn_layout)
        
        # 输出区
        output_widget = QWidget()
        output_layout = QVBoxLayout(output_widget)
        output_label = QLabel('输出结果:')
        output_text = self.create_text_edit()
        output_layout.addWidget(output_label)
        output_layout.addWidget(output_text)
        
        # 添加到分割器
        splitter.addWidget(input_widget)
        splitter.addWidget(output_widget)
        layout.addWidget(splitter)
        
        # 绑定事件
        format_btn.clicked.connect(lambda: self.format_json(input_text, output_text))
        validate_btn.clicked.connect(lambda: self.validate_json(input_text, output_text))
        to_sql_btn.clicked.connect(lambda: self.json_to_sql(input_text, output_text))
        
        return widget
    
    def create_url_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # URL输入
        input_label = QLabel('输入URL:')
        input_text = QTextEdit()
        layout.addWidget(input_label)
        layout.addWidget(input_text)
        
        # 按钮区
        btn_layout = QHBoxLayout()
        encode_btn = QPushButton('编码')
        decode_btn = QPushButton('解码')
        parse_btn = QPushButton('解析参数')
        btn_layout.addWidget(encode_btn)
        btn_layout.addWidget(decode_btn)
        btn_layout.addWidget(parse_btn)
        layout.addLayout(btn_layout)
        
        # 输出区
        output_label = QLabel('输出结果:')
        output_text = QTextEdit()
        layout.addWidget(output_label)
        layout.addWidget(output_text)
        
        # 绑定事件
        encode_btn.clicked.connect(lambda: self.url_encode(input_text, output_text))
        decode_btn.clicked.connect(lambda: self.url_decode(input_text, output_text))
        parse_btn.clicked.connect(lambda: self.parse_url(input_text, output_text))
        
        return widget

    def create_format_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # 输入区
        input_label = QLabel('输入内容:')
        input_text = QTextEdit()
        layout.addWidget(input_label)
        layout.addWidget(input_text)
        
        # 按钮区
        btn_layout = QHBoxLayout()
        html_btn = QPushButton('HTML格式化')
        js_btn = QPushButton('JS格式化')
        header_btn = QPushButton('Header格式化')
        cookie_btn = QPushButton('Cookie格式化')
        btn_layout.addWidget(html_btn)
        btn_layout.addWidget(js_btn)
        btn_layout.addWidget(header_btn)
        btn_layout.addWidget(cookie_btn)
        layout.addLayout(btn_layout)
        
        # 输出区
        output_label = QLabel('输出结果:')
        output_text = QTextEdit()
        layout.addWidget(output_label)
        layout.addWidget(output_text)
        
        # 绑定事件
        html_btn.clicked.connect(lambda: self.format_html(input_text, output_text))
        js_btn.clicked.connect(lambda: self.format_js(input_text, output_text))
        header_btn.clicked.connect(lambda: self.format_headers(input_text, output_text))
        cookie_btn.clicked.connect(lambda: self.format_cookies(input_text, output_text))
        
        return widget

    def create_encode_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # 输入区
        input_label = QLabel('输入内容:')
        input_text = QTextEdit()
        layout.addWidget(input_label)
        layout.addWidget(input_text)
        
        # 按钮区
        btn_layout = QHBoxLayout()
        base64_encode_btn = QPushButton('Base64编码')
        base64_decode_btn = QPushButton('Base64解码')
        url_encode_btn = QPushButton('URL编码')
        url_decode_btn = QPushButton('URL解码')
        btn_layout.addWidget(base64_encode_btn)
        btn_layout.addWidget(base64_decode_btn)
        btn_layout.addWidget(url_encode_btn)
        btn_layout.addWidget(url_decode_btn)
        layout.addLayout(btn_layout)
        
        # 输出区
        output_label = QLabel('输出结果:')
        output_text = QTextEdit()
        layout.addWidget(output_label)
        layout.addWidget(output_text)
        
        # 绑定事件
        base64_encode_btn.clicked.connect(lambda: self.base64_encode(input_text, output_text))
        base64_decode_btn.clicked.connect(lambda: self.base64_decode(input_text, output_text))
        url_encode_btn.clicked.connect(lambda: self.url_encode(input_text, output_text))
        url_decode_btn.clicked.connect(lambda: self.url_decode(input_text, output_text))
        
        return widget

    def create_compare_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # 左侧输入
        left_label = QLabel('文本 1:')
        left_text = QTextEdit()
        layout.addWidget(left_label)
        layout.addWidget(left_text)
        
        # 右侧输入
        right_label = QLabel('文本 2:')
        right_text = QTextEdit()
        layout.addWidget(right_label)
        layout.addWidget(right_text)
        
        # 按钮
        compare_btn = QPushButton('比较')
        layout.addWidget(compare_btn)
        
        # 结果输出
        result_label = QLabel('对比结果:')
        result_text = QTextEdit()
        layout.addWidget(result_label)
        layout.addWidget(result_text)
        
        # 绑定事件
        compare_btn.clicked.connect(lambda: self.compare_text(left_text, right_text, result_text))
        
        return widget

    def create_crypto_tab(self):
        widget = QWidget()
        layout = QVBoxLayout(widget)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # 使用QSplitter来分割输入和输出区域
        splitter = QSplitter(Qt.Orientation.Vertical)
        
        # 输入区
        input_widget = QWidget()
        input_layout = QVBoxLayout(input_widget)
        input_label = QLabel('输入内容:')
        input_text = self.create_text_edit()
        input_layout.addWidget(input_label)
        input_layout.addWidget(input_text)
        
        # 密钥输入区（可选）
        key_layout = QHBoxLayout()
        key_label = QLabel('密钥:')
        key_text = QTextEdit()
        key_text.setMaximumHeight(30)
        key_layout.addWidget(key_label)
        key_layout.addWidget(key_text)
        input_layout.addLayout(key_layout)
        
        # 按钮区
        btn_layout = QHBoxLayout()
        
        # 哈希算法
        hash_group = QVBoxLayout()
        hash_label = QLabel('哈希算法:')
        
        # MD5选项组
        md5_group = QHBoxLayout()
        md5_btn = self.create_button('MD5')
        md5_16_btn = self.create_button('MD5-16位')
        md5_salt_btn = self.create_button('MD5+盐')
        md5_upper_btn = self.create_button('MD5大写')
        md5_group.addWidget(md5_btn)
        md5_group.addWidget(md5_16_btn)
        md5_group.addWidget(md5_salt_btn)
        md5_group.addWidget(md5_upper_btn)
        hash_group.addLayout(md5_group)
        
        # 其他哈希按钮
        sha1_btn = self.create_button('SHA1')
        sha256_btn = self.create_button('SHA256')
        sha512_btn = self.create_button('SHA512')
        hash_group.addWidget(sha1_btn)
        hash_group.addWidget(sha256_btn)
        hash_group.addWidget(sha512_btn)
        btn_layout.addLayout(hash_group)
        
        # 对称加密
        symmetric_group = QVBoxLayout()
        symmetric_label = QLabel('对称加密:')
        aes_encrypt_btn = self.create_button('AES加密')
        aes_decrypt_btn = self.create_button('AES解密')
        des_encrypt_btn = self.create_button('DES加密')
        des_decrypt_btn = self.create_button('DES解密')
        symmetric_group.addWidget(symmetric_label)
        symmetric_group.addWidget(aes_encrypt_btn)
        symmetric_group.addWidget(aes_decrypt_btn)
        symmetric_group.addWidget(des_encrypt_btn)
        symmetric_group.addWidget(des_decrypt_btn)
        btn_layout.addLayout(symmetric_group)
        
        # 编码转换
        encoding_group = QVBoxLayout()
        encoding_label = QLabel('编码转换:')
        hex_encode_btn = self.create_button('HEX编码')
        hex_decode_btn = self.create_button('HEX解码')
        base32_encode_btn = self.create_button('Base32编码')
        base32_decode_btn = self.create_button('Base32解码')
        encoding_group.addWidget(encoding_label)
        encoding_group.addWidget(hex_encode_btn)
        encoding_group.addWidget(hex_decode_btn)
        encoding_group.addWidget(base32_encode_btn)
        encoding_group.addWidget(base32_decode_btn)
        btn_layout.addLayout(encoding_group)
        
        input_layout.addLayout(btn_layout)
        
        # 输出区
        output_widget = QWidget()
        output_layout = QVBoxLayout(output_widget)
        output_label = QLabel('输出结果:')
        output_text = self.create_text_edit()
        output_layout.addWidget(output_label)
        output_layout.addWidget(output_text)
        
        # 添加到分割器
        splitter.addWidget(input_widget)
        splitter.addWidget(output_widget)
        layout.addWidget(splitter)
        
        # 绑定事件
        md5_btn.clicked.connect(lambda: self.hash_text('md5', input_text, output_text))
        md5_16_btn.clicked.connect(lambda: self.hash_text('md5-16', input_text, output_text))
        md5_salt_btn.clicked.connect(lambda: self.hash_text('md5-salt', input_text, key_text, output_text))
        md5_upper_btn.clicked.connect(lambda: self.hash_text('md5-upper', input_text, output_text))
        
        sha1_btn.clicked.connect(lambda: self.hash_text('sha1', input_text, output_text))
        sha256_btn.clicked.connect(lambda: self.hash_text('sha256', input_text, output_text))
        sha512_btn.clicked.connect(lambda: self.hash_text('sha512', input_text, output_text))
        
        aes_encrypt_btn.clicked.connect(lambda: self.aes_encrypt(input_text, key_text, output_text))
        aes_decrypt_btn.clicked.connect(lambda: self.aes_decrypt(input_text, key_text, output_text))
        des_encrypt_btn.clicked.connect(lambda: self.des_encrypt(input_text, key_text, output_text))
        des_decrypt_btn.clicked.connect(lambda: self.des_decrypt(input_text, key_text, output_text))
        
        hex_encode_btn.clicked.connect(lambda: self.hex_encode(input_text, output_text))
        hex_decode_btn.clicked.connect(lambda: self.hex_decode(input_text, output_text))
        base32_encode_btn.clicked.connect(lambda: self.base32_encode(input_text, output_text))
        base32_decode_btn.clicked.connect(lambda: self.base32_decode(input_text, output_text))
        
        return widget

    def format_json(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            formatted = json.dumps(json.loads(text), indent=4, ensure_ascii=False)
            output_text.setPlainText(formatted)
        except Exception as e:
            output_text.setPlainText(f"格式化错误: {str(e)}")

    def validate_json(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            json.loads(text)
            output_text.setPlainText("JSON格式有效")
        except Exception as e:
            output_text.setPlainText(f"JSON格式无效: {str(e)}")

    def json_to_sql(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            data = json.loads(text)
            if not isinstance(data, dict):
                raise ValueError("只支持单层JSON对象转换")
            
            table_name = "table_name"
            columns = ', '.join(data.keys())
            values = ', '.join([f"'{v}'" if isinstance(v, str) else str(v) for v in data.values()])
            sql = f"INSERT INTO {table_name} ({columns}) VALUES ({values});"
            output_text.setPlainText(sql)
        except Exception as e:
            output_text.setPlainText(f"转换失败: {str(e)}")

    def format_html(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            soup = BeautifulSoup(text, 'html.parser')
            output_text.setPlainText(soup.prettify())
        except Exception as e:
            output_text.setPlainText(f"格式化错误: {str(e)}")

    def format_js(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            formatted = jsbeautifier.beautify(text)
            output_text.setPlainText(formatted)
        except Exception as e:
            output_text.setPlainText(f"格式化错误: {str(e)}")

    def format_headers(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            headers = {}
            for line in text.splitlines():
                if ':' in line:
                    key, value = line.split(':', 1)
                    headers[key.strip()] = value.strip()
            output_text.setPlainText(json.dumps(headers, indent=4, ensure_ascii=False))
        except Exception as e:
            output_text.setPlainText(f"格式化错误: {str(e)}")

    def format_cookies(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            cookies = {}
            items = text.split(';')
            for item in items:
                if '=' in item:
                    key, value = item.split('=', 1)
                    cookies[key.strip()] = value.strip()
            output_text.setPlainText(json.dumps(cookies, indent=4, ensure_ascii=False))
        except Exception as e:
            output_text.setPlainText(f"格式化错误: {str(e)}")

    def parse_url(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            parsed = urlparse(text)
            params = parse_qs(parsed.query)
            result = {
                "scheme": parsed.scheme,
                "netloc": parsed.netloc,
                "path": parsed.path,
                "params": params
            }
            output_text.setPlainText(json.dumps(result, indent=4, ensure_ascii=False))
        except Exception as e:
            output_text.setPlainText(f"解析错误: {str(e)}")

    def base64_encode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            encoded = base64.b64encode(text.encode()).decode()
            output_text.setPlainText(encoded)
        except Exception as e:
            output_text.setPlainText(f"编码错误: {str(e)}")

    def base64_decode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            decoded = base64.b64decode(text).decode()
            output_text.setPlainText(decoded)
        except Exception as e:
            output_text.setPlainText(f"解码错误: {str(e)}")

    def url_encode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            encoded = quote(text)
            output_text.setPlainText(encoded)
        except Exception as e:
            output_text.setPlainText(f"编码错误: {str(e)}")

    def url_decode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            decoded = unquote(text)
            output_text.setPlainText(decoded)
        except Exception as e:
            output_text.setPlainText(f"解码错误: {str(e)}")

    def compare_text(self, left_text, right_text, result_text):
        try:
            text1 = left_text.toPlainText().splitlines()
            text2 = right_text.toPlainText().splitlines()
            diff = difflib.unified_diff(text1, text2, lineterm='')
            result_text.setPlainText('\n'.join(diff))
        except Exception as e:
            result_text.setPlainText(f"比较错误: {str(e)}")

    def hash_text(self, algorithm, input_text, output_text, key_text=None):
        try:
            text = input_text.toPlainText().encode()
            
            if algorithm == 'md5':
                result = hashlib.md5(text).hexdigest()
            elif algorithm == 'md5-16':
                # 取32位MD5的中间16位
                result = hashlib.md5(text).hexdigest()[8:-8]
            elif algorithm == 'md5-salt':
                if key_text is None:
                    raise ValueError("需要提供盐值")
                salt = key_text.toPlainText().encode()
                # 前盐
                salted_text = salt + text
                result_pre = hashlib.md5(salted_text).hexdigest()
                # 后盐
                salted_text = text + salt
                result_post = hashlib.md5(salted_text).hexdigest()
                result = f"前盐: {result_pre}\n后盐: {result_post}"
            elif algorithm == 'md5-upper':
                result = hashlib.md5(text).hexdigest().upper()
            elif algorithm == 'sha1':
                result = hashlib.sha1(text).hexdigest()
            elif algorithm == 'sha256':
                result = hashlib.sha256(text).hexdigest()
            elif algorithm == 'sha512':
                result = hashlib.sha512(text).hexdigest()
            
            # 添加结果说明
            if algorithm == 'md5-16':
                result = f"16位MD5: {result}"
            elif algorithm == 'md5-upper':
                result = f"大写MD5: {result}"
            elif algorithm == 'md5' and not algorithm.startswith('md5-'):
                result = f"32位MD5: {result}"
            
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"哈希计算错误: {str(e)}")

    def aes_encrypt(self, input_text, key_text, output_text):
        try:
            text = input_text.toPlainText().encode()
            # 生成密钥
            key = Fernet.generate_key() if not key_text.toPlainText() else key_text.toPlainText().encode()
            f = Fernet(key)
            # 加密
            encrypted = f.encrypt(text)
            # 输出密文和密钥
            result = f"密文: {encrypted.decode()}\n密钥: {key.decode()}"
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"加密错误: {str(e)}")

    def aes_decrypt(self, input_text, key_text, output_text):
        try:
            encrypted = input_text.toPlainText().encode()
            key = key_text.toPlainText().encode()
            f = Fernet(key)
            # 解密
            decrypted = f.decrypt(encrypted)
            output_text.setPlainText(decrypted.decode())
        except Exception as e:
            output_text.setPlainText(f"解密错误: {str(e)}")

    def hex_encode(self, input_text, output_text):
        try:
            text = input_text.toPlainText().encode()
            result = text.hex()
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"HEX编码错误: {str(e)}")

    def hex_decode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            result = bytes.fromhex(text).decode()
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"HEX解码错误: {str(e)}")

    def base32_encode(self, input_text, output_text):
        try:
            text = input_text.toPlainText().encode()
            result = base64.b32encode(text).decode()
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"Base32编码错误: {str(e)}")

    def base32_decode(self, input_text, output_text):
        try:
            text = input_text.toPlainText()
            result = base64.b32decode(text).decode()
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"Base32解码错误: {str(e)}")

    def des_encrypt(self, input_text, key_text, output_text):
        try:
            # 获取输入文本
            text = input_text.toPlainText().encode()
            
            # 生成或使用提供的密钥（DES需要24字节密钥）
            if key_text.toPlainText():
                key = key_text.toPlainText().encode()
                # 确保密钥长度为24字节
                key = key * (24 // len(key) + 1)
                key = key[:24]
            else:
                key = os.urandom(24)  # 生成24字节随机密钥

            # 生成初始化向量
            iv = os.urandom(8)  # TripleDES需要8字节IV

            # 创建加密器
            cipher = Cipher(
                algorithms.TripleDES(key),
                modes.CBC(iv),
                backend=default_backend()
            )
            encryptor = cipher.encryptor()

            # 填充数据
            pad_length = 8 - (len(text) % 8)
            padded_text = text + bytes([pad_length] * pad_length)

            # 加密
            encrypted = encryptor.update(padded_text) + encryptor.finalize()
            
            # 组合IV和密文，并进行Base64编码
            final_data = base64.b64encode(iv + encrypted).decode()
            
            # 输出结果
            result = f"密文: {final_data}\n密钥: {base64.b64encode(key).decode()}"
            output_text.setPlainText(result)
        except Exception as e:
            output_text.setPlainText(f"DES加密错误: {str(e)}")

    def des_decrypt(self, input_text, key_text, output_text):
        try:
            # 获取密文和密钥
            encrypted_data = base64.b64decode(input_text.toPlainText())
            key = base64.b64decode(key_text.toPlainText())

            # 提取IV和密文
            iv = encrypted_data[:8]
            encrypted = encrypted_data[8:]

            # 创建解密器
            cipher = Cipher(
                algorithms.TripleDES(key),
                modes.CBC(iv),
                backend=default_backend()
            )
            decryptor = cipher.decryptor()

            # 解密
            decrypted_padded = decryptor.update(encrypted) + decryptor.finalize()
            
            # 去除填充
            pad_length = decrypted_padded[-1]
            decrypted = decrypted_padded[:-pad_length]

            # 输出结果
            output_text.setPlainText(decrypted.decode())
        except Exception as e:
            output_text.setPlainText(f"DES解密错误: {str(e)}")

    def generate_salt(self, length=16):
        """生成指定长度的随机盐"""
        return os.urandom(length).hex() 

[Python] 纯文本查看 复制代码

import json
import jsbeautifier
from bs4 import BeautifulSoup
from urllib.parse import urlparse, parse_qs, quote, unquote
import base64
from datetime import datetime

class FormatUtils:
    @staticmethod
    def format_json(json_str):
        try:
            parsed = json.loads(json_str)
            return json.dumps(parsed, indent=4, ensure_ascii=False)
        except Exception as e:
            return f"JSON格式化错误: {str(e)}"

    @staticmethod
    def validate_json(json_str):
        try:
            json.loads(json_str)
            return "JSON格式有效"
        except Exception as e:
            return f"JSON格式无效: {str(e)}"

    @staticmethod
    def json_to_sql(json_str):
        try:
            data = json.loads(json_str)
            if not isinstance(data, dict):
                return "只支持单层JSON对象转换"
            
            table_name = "table_name"  # 可以让用户输入
            columns = ', '.join(data.keys())
            values = ', '.join([f"'{v}'" if isinstance(v, str) else str(v) for v in data.values()])
            return f"INSERT INTO {table_name} ({columns}) VALUES ({values});"
        except Exception as e:
            return f"转换失败: {str(e)}"

    @staticmethod
    def format_html(html_str):
        try:
            soup = BeautifulSoup(html_str, 'html.parser')
            return soup.prettify()
        except Exception as e:
            return f"HTML格式化错误: {str(e)}"

    @staticmethod
    def format_js(js_str):
        try:
            return jsbeautifier.beautify(js_str)
        except Exception as e:
            return f"JS格式化错误: {str(e)}"

    @staticmethod
    def format_headers(header_str):
        try:
            headers = {}
            for line in header_str.splitlines():
                if ':' in line:
                    key, value = line.split(':', 1)
                    headers[key.strip()] = value.strip()
            return json.dumps(headers, indent=4, ensure_ascii=False)
        except Exception as e:
            return f"Header格式化错误: {str(e)}"

    @staticmethod
    def format_cookies(cookie_str):
        try:
            cookies = {}
            items = cookie_str.split(';')
            for item in items:
                if '=' in item:
                    key, value = item.split('=', 1)
                    cookies[key.strip()] = value.strip()
            return json.dumps(cookies, indent=4, ensure_ascii=False)
        except Exception as e:
            return f"Cookie格式化错误: {str(e)}" 

[Python] 纯文本查看 复制代码

import sys
from PyQt6.QtWidgets import QApplication
from main import FormatTool

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = FormatTool()
    window.show()
    sys.exit(app.exec()) 

Evam

geniusrot 发表于 2025-2-19 16:49
运行不了，没有错误提示，直接退出运行了

他这个是运行app.py。
main.py和utils.py里面是两个封装好的方法，app.py里才是if __name__ == '__main__':

tooooony

感谢开源工具，之前做过header/payload格式化的工具，比这个解析复杂很多，处理应对的各种不规范情况更多。

[Python] 纯文本查看 复制代码

            lines = input_text.split('\n')
            lines = [line.strip() for line in lines if line.strip() != '']
            formatted_headers = {}
            key, value, next_key, next_value = None, None, None, None
            i, n = 0, len(lines)
            while i < n:
                line = lines[i]
                if key is None:
                    if line == ':':
                        key = ''
                    elif line.endswith(':'):
                        key = line[:-1].strip()
                    else:
                        _a, _b = line.find(':'), line.rfind(':')
                        if _a == -1:  # 不包含冒号, 则该行就是key
                            key = line
                        else:
                            if _a == _b:  # 仅包含一个冒号
                                if _a == 0:  # 冒号在开头, 该行为key
                                    key = line
                                else:   # 冒号不在开头
                                    key = line[:_a]
                                    value = line[_a+1:].strip()
                            else:  # 包含多个冒号
                                if _a == 0:  # 开头有冒号
                                    key = line[:line.index(':', 1)]  # key为第二个冒号之前的内容
                                    value = line[line.index(':', 1)+1:] # value为第二个冒号之后的内容
                                else:
                                    key = line[:_a]
                                    value = line[_a+1:]
                else:
                    if value is None:
                        if line == ':':
                            pass
                        elif line.endswith(':'):
                            value = ''
                            next_key = line[:-1].strip()
                        else:
                            _a, _b = line.find(':'), line.rfind(':')
                            if _a == -1:  # 不包含冒号, 则该行就是value
                                value = line
                            else:
                                if _a == _b:  # 仅包含一个冒号
                                    if _a == 0:  # 冒号在开头, 该行为value
                                        value = line
                                    else:   # 冒号不在开头
                                        value = ''
                                        next_key = line[:_a].strip()
                                        next_value = line[_a+1:].strip()
                                else:  # 包含多个冒号
                                    value = ''
                                    if _a == 0:  # 开头有冒号
                                        next_key = line[:line.index(':', 1)]  # key为第二个冒号之前的内容
                                        next_value = line[line.index(':', 1)+1:] # value为第二个冒号之后的内容
                                    else:
                                        next_key = line[:_a]
                                        next_value = line[_a+1:]

                i += 1
                if key is not None and value is not None:
                    formatted_headers[key] = value
                    key = None
                    value = None
                if next_key is not None and next_value is not None:
                    formatted_headers[next_key] = next_value
                    next_key = None
                    next_value = None
                if next_key is not None:
                    key = next_key
                    next_key = None
            # 处理最后一个key
            if key is not None:
                formatted_headers[key] = ""

qianshang666

可以在网盘里把整个源码文件也分享一下吗

调味包

qianshang666 发表于 2025-2-19 12:31
可以在网盘里把整个源码文件也分享一下吗

https://www.123912.com/s/1XvlVv-sA5QA?提取码:52pj

Ffmx520530

感谢分享

wqscn

感觉分享，弱弱问句，可以实现哪些功能？

qianshang666

调味包 发表于 2025-2-19 12:33
https://www.123912.com/s/1XvlVv-sA5QA?提取码:52pj

谢谢大佬

白水饮

加密缺一个HMAC加密，另外win11暗色主题显示好像有点bug

xptk9074

Pyqt6 编译后运行不了，怎么能解决呢？ 本地编译后 到其他电脑上用

fastdun

感谢分享，支持开源

militiamag

这个好，试一下。谢谢分享