加密/解密软件基本完成

Author: 爱音爱素食

.idea/workspace.xml

@@ -117,63 +117,8 @@ def encrypt_file(self, input_path: str, output_path: str, signature: str, algo_n
 
             file_size = os.path.getsize(input_path)
             processed_size = 0
-            
-            # with open(input_path, 'rb') as f_in, open(output_path, 'wb') as f_out:
-            #     # Write header: Salt + IV
-            #     f_out.write(salt)
-            #     f_out.write(iv)
-            #
-            #     while True:
-            #         chunk = f_in.read(self.CHUNK_SIZE)
-            #         if len(chunk) == 0:
-            #             break
-            #
-            #         processed_size += len(chunk)
-            #
-            #         if len(chunk) < self.CHUNK_SIZE:
-            #             # Last chunk, needs padding
-            #             padded_chunk = self._pad_data(chunk)
-            #             f_out.write(encryptor.update(padded_chunk) + encryptor.finalize())
-            #         else:
-            #             # Full chunk.
-            #             # Note: Padding PKCS7 on stream is tricky.
-            #             # Usually we treat the whole file as one message.
-            #             # Standard approach for streams: Pad only the last block.
-            #             # Cryptography's padder handles this if we feed it right,
-            #             # but we need to know if it's the last chunk.
-            #             # The 'padder' object is stateful? No, padder is for one-shot or update().
-            #             # Actually, `padding.PKCS7` padder doesn't support stream updating easily if we don't know the end.
-            #             # BUT, we do know the end (len(chunk) < CHUNK_SIZE or next read is empty).
-            #             # Let's use a simpler approach: Read all? No, memory issues.
-            #             # Correct streaming padding:
-            #             # 1. Read chunk.
-            #             # 2. If it's the last chunk (EOF), pad it and encrypt.
-            #             # 3. If not last, encrypt raw.
-            #             # Wait, AES requires blocks of 16 bytes. If chunk is 64KB, it's a multiple of 16.
-            #             # So we can encrypt full chunks directly.
-            #             # Only the last chunk needs padding.
-            #
-            #             # Logic revision:
-            #             # AES CBC works on blocks. 64KB is multiple of 16.
-            #             # We can encrypt valid blocks directly.
-            #             # We only need the padder for the *final* bytes.
-            #             # BUT, PKCS7 always adds padding, even if multiple of 16 (adds a full block of 16s).
-            #             # So we can effectively say:
-            #             # - Loop read.
-            #             # - If next read is empty, this was the last chunk.
-            #             # - But we don't know if next read is empty until we try.
-            #             # Buffered approach:
-            #             pass
-            #
-            #         if progress_callback:
-            #             progress_callback(processed_size, file_size)
-
-            # Re-implementing file loop for correct padding
-            # We need to ensure we pad the final block.
-            # And we must ensure previous blocks are multiples of 16.
-            
-            # Reset
-            encryptor = cipher.encryptor() # Fresh encryptor
+
+            encryptor = cipher.encryptor()
             padder = padding.PKCS7(128).padder()
 
             with open(input_path, 'rb') as f_in, open(output_path, 'wb') as f_out:
@@ -183,10 +128,6 @@ def encrypt_file(self, input_path: str, output_path: str, signature: str, algo_n
                 while True:
                     chunk = f_in.read(self.CHUNK_SIZE)
                     if len(chunk) == 0:
-                        # End of file. Finalize padding.
-                        # The padder might have pending data? No, we feed chunk by chunk.
-                        # If we feed chunk to padder.update(), it buffers.
-                        # Let's do this:
                         final_data = padder.finalize()
                         f_out.write(encryptor.update(final_data) + encryptor.finalize())
                         break
@@ -233,8 +174,6 @@ def decrypt_file(self, input_path: str, output_path: str, signature: str, algo_n
                             # End of stream
                             final_unpadded = unpadder.finalize()
                             f_out.write(final_unpadded)
-                            # Decryptor finalize usually returns empty for CBC if aligned? 
-                            # Actually decryptor.finalize() checks for leftover bytes which shouldn't exist in CBC if padded correctly.
                             decryptor.finalize() 
                             break
 

crypto_manager.py

@@ -3,6 +3,7 @@
 import threading
 import os
 import datetime
+import json
 from crypto_manager import CryptoManager
 
 # Try to import tkinterdnd2 for Drag and Drop support
@@ -54,6 +55,8 @@
     "lang_label": {"en": "Language:", "zh": "语言:"}
 }
 
+CONFIG_FILE = "settings.json"
+
 class EncryptApp(BaseWindow):
     def __init__(self):
         super().__init__()
@@ -65,10 +68,38 @@ def __init__(self):
 
         self.lang_code = "en"
         self.translatable_widgets = [] # List of (widget, key, attribute_name)
+        
+        # Load settings before UI setup to apply language and paths
+        self.load_settings()
 
         self.setup_ui()
-        self.update_language() # Initial text set
+        self.update_language() # Apply language to UI
 
+    def load_settings(self):
+        """Load settings from JSON file."""
+        if os.path.exists(CONFIG_FILE):
+            try:
+                with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
+                    settings = json.load(f)
+                    self.enc_output_path.set(settings.get("enc_output_path", ""))
+                    self.dec_output_path.set(settings.get("dec_output_path", ""))
+                    self.lang_code = settings.get("language", "en")
+            except Exception as e:
+                print(f"Failed to load settings: {e}")
+
+    def save_settings(self):
+        """Save current settings to JSON file."""
+        settings = {
+            "enc_output_path": self.enc_output_path.get(),
+            "dec_output_path": self.dec_output_path.get(),
+            "language": self.lang_code
+        }
+        try:
+            with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
+                json.dump(settings, f, ensure_ascii=False, indent=4)
+        except Exception as e:
+            print(f"Failed to save settings: {e}")
+
     def tr(self, key):
         """Translate a key to the current language."""
         return TRANSLATIONS.get(key, {}).get(self.lang_code, key)
@@ -95,6 +126,9 @@ def update_language(self, event=None):
                 self.lang_code = "zh"
             else:
                 self.lang_code = "en"
+            
+            # Save new language preference
+            self.save_settings()
 
         # Update registered widgets
         for widget, key, attr in self.translatable_widgets:
@@ -108,9 +142,6 @@ def update_language(self, event=None):
                     print(f"Failed to update widget {widget}: {e}")
 
         # Update dynamic status labels if they are "Ready"
-        # (This is a bit tricky, but we can reset them to Ready on lang change if they were Ready)
-        # Simplified: We just leave them as is, next operation will use new lang.
-        # But we can force update the "Ready" state if idle.
         if self.enc_status.cget("text") in ["Ready", "就绪"]:
              self.enc_status.config(text=self.tr("ready"))
         if self.dec_status.cget("text") in ["Ready", "就绪"]:
@@ -154,7 +185,12 @@ def setup_ui(self):
         lbl_lang.pack(side="left", padx=5)
 
         self.lang_combo = ttk.Combobox(top_frame, values=["English", "中文 (Chinese)"], state="readonly", width=15)
-        self.lang_combo.set("English")
+        # Set initial selection based on loaded settings
+        if self.lang_code == "zh":
+            self.lang_combo.set("中文 (Chinese)")
+        else:
+            self.lang_combo.set("English")
+            
         self.lang_combo.pack(side="left", padx=5)
         self.lang_combo.bind("<<ComboboxSelected>>", self.update_language)
 
@@ -203,14 +239,12 @@ def create_text_section(self, parent, col, title_key, btn_text_key, btn_command)
         log_area = scrolledtext.ScrolledText(frame, height=15, state="disabled", font=("Consolas", 9))
         log_area.pack(fill="both", expand=True, pady=(0, 5))
 
-        if "Encrypt" in self.tr(btn_text_key) or "加密" in self.tr(btn_text_key): # Check intent via key ideally, but simplistic here
-            # Better to use the key passed
+        if "Encrypt" in self.tr(btn_text_key) or "加密" in self.tr(btn_text_key):
              if btn_text_key == "btn_encrypt":
                 self.enc_log = log_area
              else:
                 self.dec_log = log_area
         else:
-            # Fallback if I messed up logic above, rely on passed key
              if btn_text_key == "btn_encrypt":
                 self.enc_log = log_area
              else:
@@ -321,11 +355,15 @@ def confirm_signature(self):
 
     def select_enc_out_dir(self):
         d = filedialog.askdirectory()
-        if d: self.enc_output_path.set(d)
+        if d: 
+            self.enc_output_path.set(d)
+            self.save_settings()
 
     def select_dec_out_dir(self):
         d = filedialog.askdirectory()
-        if d: self.dec_output_path.set(d)
+        if d: 
+            self.dec_output_path.set(d)
+            self.save_settings()
 
     def select_file(self, var):
         f = filedialog.askopenfilename()
@@ -378,6 +416,14 @@ def _run_file_op(self, input_var, output_dir_var, op_func, pb, status_lbl, suffi
             return
 
         out_dir = output_dir_var.get()
+        if out_dir:
+            if not os.path.exists(out_dir):
+                try:
+                    os.makedirs(out_dir)
+                except OSError:
+                    # If cannot create, fallback to input directory
+                    out_dir = ""
+        
         if not out_dir:
             out_dir = os.path.dirname(in_path)
 

main.py

@@ -1,2 +1,4 @@
-cryptography>=41.0.0
-tkinterdnd2>=0.3.0
+cffi==2.0.0
+cryptography==41.0.0
+pycparser==2.23
+tkinterdnd2==0.3.0