Improve RSA block size detection for variable base64 lengths

encryption.py

@@ -120,41 +120,64 @@ def decrypt_data(encrypted_base64: str) -> Optional[Any]:
         return {"encrypted_data": encrypted_base64, "decryption_error": str(e)}
 
 
-def decrypt_multiple_blocks(encrypted_data: str, block_size: int = 344) -> list[Any]:
+def decrypt_multiple_blocks(encrypted_data: str) -> list[Any]:
     """
     Decrypt multiple concatenated encrypted blocks.
     
-    RSA 2048-bit encrypted data is typically 256 bytes, which is ~344 chars in base64.
+    RSA 2048-bit encrypted data is 256 bytes, which can be:
+    - 344 chars in base64 with padding
+    - 342 chars in base64 without padding (URL-safe)
+    
+    This function tries multiple block sizes to find the right one.
     
     Args:
         encrypted_data: Concatenated base64-encoded encrypted blocks
-        block_size: Size of each encrypted block in base64 chars (default 344 for RSA-2048)
         
     Returns:
         List of decrypted data objects
     """
     results = []
     
-    # If the data is smaller than block_size, treat as single block
-    if len(encrypted_data) <= block_size:
-        try:
-            result = decrypt_data(encrypted_data)
-            if result:
-                results.append(result)
-        except Exception as e:
-            logger.error(f"Failed to decrypt single block: {e}")
+    # Common block sizes for RSA-2048 in base64
+    # 344 = with padding, 342 = without padding
+    POSSIBLE_BLOCK_SIZES = [344, 342, 343, 256]
+    
+    # First, try to decrypt as a single block
+    if len(encrypted_data) <= 350:
+        result = decrypt_data(encrypted_data)
+        if result:
+            results.append(result)
         return results
     
-    # Split into blocks and decrypt each
+    # Try each possible block size
+    for block_size in POSSIBLE_BLOCK_SIZES:
+        # Check if data length is divisible by block size
+        if len(encrypted_data) % block_size == 0:
+            blocks_results = []
+            success = True
+            
+            for i in range(0, len(encrypted_data), block_size):
+                block = encrypted_data[i:i + block_size]
+                result = decrypt_data(block)
+                if result and "decryption_error" not in result:
+                    blocks_results.append(result)
+                else:
+                    success = False
+                    break
+            
+            if success and blocks_results:
+                logger.info(f"Successfully decrypted {len(blocks_results)} blocks with block_size={block_size}")
+                return blocks_results
+    
+    # Fallback: try to decrypt with default block size 344, collecting all results
+    block_size = 344
+    logger.warning(f"Falling back to block_size={block_size}, data length={len(encrypted_data)}")
+    
     for i in range(0, len(encrypted_data), block_size):
         block = encrypted_data[i:i + block_size]
-        if block:  # Skip empty blocks
-            try:
-                result = decrypt_data(block)
-                if result:
-                    results.append(result)
-            except Exception as e:
-                logger.error(f"Failed to decrypt block {i // block_size}: {e}")
-                continue
+        if block:
+            result = decrypt_data(block)
+            if result:
+                results.append(result)
     
     return results