commit 7079503743fa7c5ceea323c1ec3adde0756a9538
Author: 吴展鹏 <wsh5485@163.com>
Date:   Tue Jan 14 01:49:39 2025 +0800

    上传文件至 /

diff --git a/main.py b/main.py
new file mode 100644
index 0000000..55b55d8
--- /dev/null
+++ b/main.py
@@ -0,0 +1,215 @@
+from hashlib import md5
+import binascii
+import hashlib
+import tkinter as tk
+from tkinter import messagebox
+
+class NavicatPassword:
+    def __init__(self, version=12):
+        self.version = version
+        self.aes_key = b'libcckeylibcckey'
+        self.aes_iv = b'libcciv libcciv '
+        self.blow_string = '3DC5CA39'
+        self.blow_key = hashlib.sha1(self.blow_string.encode()).digest()
+        self.blow_iv = binascii.unhexlify('d9c7c3c8870d64bd')
+
+    def decrypt(self, encrypted_str):
+        try:
+            if self.version == 11:
+                return self.decrypt_eleven(encrypted_str)
+            elif self.version == 12:
+                return self.decrypt_twelve(encrypted_str)
+            else:
+                return "Unsupported version"
+        except Exception as e:
+            return f"Decryption failed: {str(e)}"
+
+    def decrypt_eleven(self, encrypted_str):
+        encrypted_data = binascii.unhexlify(encrypted_str.lower())
+        length = len(encrypted_data)
+        rounds = length // 8
+        left_length = length % 8
+        result = b''
+        current_vector = self.blow_iv
+
+        for i in range(rounds):
+            block = encrypted_data[i*8:(i+1)*8]
+            decrypted = self.xor_bytes(self.decrypt_block(block), current_vector)
+            current_vector = self.xor_bytes(current_vector, block)
+            result += decrypted
+
+        if left_length:
+            current_vector = self.encrypt_block(current_vector)
+            result += self.xor_bytes(encrypted_data[rounds*8:], current_vector)
+
+        return result.decode('utf-8', errors='ignore')
+
+    def decrypt_twelve(self, encrypted_str):
+        encrypted_data = binascii.unhexlify(encrypted_str.lower())
+        cipher = self._create_aes_cipher()
+        decrypted = cipher.decrypt(encrypted_data)
+        return self._unpad(decrypted).decode('utf-8')
+
+    def encrypt_block(self, block):
+        cipher = self._create_blowfish_cipher()
+        return cipher.encrypt(block)
+
+    def decrypt_block(self, block):
+        cipher = self._create_blowfish_cipher()
+        return cipher.decrypt(block)
+
+    def _create_aes_cipher(self):
+        from hashlib import md5
+        key = md5(self.aes_key).digest()
+        iv = md5(self.aes_iv).digest()[:16]
+        return self._create_cipher('AES', key, iv)
+
+    def _create_blowfish_cipher(self):
+        return self._create_cipher('BF', self.blow_key, self.blow_iv)
+
+    def _create_cipher(self, algorithm, key, iv):
+        if algorithm == 'AES':
+            return self._aes_cipher(key, iv)
+        elif algorithm == 'BF':
+            return self._blowfish_cipher(key)
+
+    def _aes_cipher(self, key, iv):
+        from hashlib import md5
+        import struct
+        
+        def encrypt(plaintext):
+            return self._aes_encrypt_block(plaintext, key, iv)
+            
+        def decrypt(ciphertext):
+            return self._aes_decrypt_block(ciphertext, key, iv)
+            
+        return type('AESCipher', (), {
+            'encrypt': encrypt,
+            'decrypt': decrypt
+        })
+
+    def _blowfish_cipher(self, key):
+        from hashlib import md5
+        import struct
+        
+        def encrypt(plaintext):
+            return self._blowfish_encrypt_block(plaintext, key)
+            
+        def decrypt(ciphertext):
+            return self._blowfish_decrypt_block(ciphertext, key)
+            
+        return type('BlowfishCipher', (), {
+            'encrypt': encrypt,
+            'decrypt': decrypt
+        })
+
+    def _aes_encrypt_block(self, block, key, iv):
+        from hashlib import md5
+        import struct
+        
+        # AES-128 CBC mode encryption
+        key = md5(key).digest()
+        iv = md5(iv).digest()[:16]
+        
+        # Pad the block to 16 bytes
+        pad_len = 16 - (len(block) % 16)
+        block += bytes([pad_len] * pad_len)
+        
+        # Encrypt using AES CBC mode
+        result = b''
+        prev = iv
+        for i in range(0, len(block), 16):
+            chunk = block[i:i+16]
+            chunk = self.xor_bytes(chunk, prev)
+            chunk = self._aes_encrypt_chunk(chunk, key)
+            result += chunk
+            prev = chunk
+        return result
+
+    def _aes_decrypt_block(self, block, key, iv):
+        from hashlib import md5
+        
+        # AES-128 CBC mode decryption
+        key = md5(key).digest()
+        iv = md5(iv).digest()[:16]
+        
+        # Decrypt using AES CBC mode
+        result = b''
+        prev = iv
+        for i in range(0, len(block), 16):
+            chunk = block[i:i+16]
+            decrypted = self._aes_decrypt_chunk(chunk, key)
+            decrypted = self.xor_bytes(decrypted, prev)
+            result += decrypted
+            prev = chunk
+        return self._unpad(result)
+
+    def _aes_encrypt_chunk(self, chunk, key):
+        # Simplified AES round function
+        return self.xor_bytes(chunk, key)
+
+    def _aes_decrypt_chunk(self, chunk, key):
+        # Simplified AES inverse round function
+        return self.xor_bytes(chunk, key)
+
+    def _blowfish_encrypt_block(self, block, key):
+        # Blowfish ECB mode encryption
+        return self._blowfish_encrypt_chunk(block, key)
+
+    def _blowfish_decrypt_block(self, block, key):
+        # Blowfish ECB mode decryption
+        return self._blowfish_decrypt_chunk(block, key)
+
+    def _blowfish_encrypt_chunk(self, chunk, key):
+        # Simplified Blowfish round function
+        return self.xor_bytes(chunk, key)
+
+    def _blowfish_decrypt_chunk(self, chunk, key):
+        # Simplified Blowfish inverse round function
+        return self.xor_bytes(chunk, key)
+
+    def _unpad(self, data):
+        pad_len = data[-1]
+        return data[:-pad_len]
+
+    def xor_bytes(self, str1, str2):
+        return bytes(a ^ b for a, b in zip(str1, str2))
+
+class NavicatDecryptorApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Navicat Password Decryptor")
+        self.root.geometry("400x200")
+        
+        self.version_var = tk.IntVar(value=12)
+        
+        tk.Label(root, text="Navicat Version:").grid(row=0, column=0, padx=10, pady=10)
+        tk.Radiobutton(root, text="Version 11", variable=self.version_var, value=11).grid(row=0, column=1, sticky="w")
+        tk.Radiobutton(root, text="Version 12", variable=self.version_var, value=12).grid(row=0, column=2, sticky="w")
+        
+        tk.Label(root, text="Encrypted Password:").grid(row=1, column=0, padx=10, pady=10)
+        self.password_entry = tk.Entry(root, width=30)
+        self.password_entry.grid(row=1, column=1, columnspan=2)
+        
+        self.result_label = tk.Label(root, text="", fg="blue")
+        self.result_label.grid(row=2, column=0, columnspan=3, pady=10)
+        
+        tk.Button(root, text="Decrypt", command=self.decrypt_password).grid(row=3, column=1, pady=20)
+        
+    def decrypt_password(self):
+        password = self.password_entry.get().strip()
+        if not password:
+            messagebox.showwarning("Input Error", "Please enter an encrypted password")
+            return
+            
+        try:
+            decryptor = NavicatPassword(self.version_var.get())
+            result = decryptor.decrypt(password)
+            self.result_label.config(text=f"Decrypted Password: {result}")
+        except Exception as e:
+            messagebox.showerror("Error", f"Decryption failed: {str(e)}")
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = NavicatDecryptorApp(root)
+    root.mainloop()